Provides structs for wrapping function pointers and callable objects to facilitate function overloading and safe invocation.
More...
|
| template<typename Iterator , typename Distance > |
| constexpr void | advance (Iterator &it, Distance n) |
| | Advance iterator n steps.
|
| |
| template<typename Distance , typename Iterator > |
| constexpr void | advance_many (Distance d, Iterator &it) |
| |
| template<typename Distance , typename Iterator , typename Iterator2 , typename... Iterators> |
| constexpr void | advance_many (Distance d, Iterator &it, Iterator2 &it2, Iterators &...its) |
| |
template<typename... Predicates>
requires ( (Fn<Predicates, bool()> or std::convertible_to<Predicates, bool>) and ...) |
| constexpr bool | any_if (Predicates &&...predicates) |
| |
| template<typename... Ts> |
| constexpr auto | any_of_f (Ts &&...needles) noexcept |
| |
| template<typename Container , typename... Args> |
| constexpr auto | append (Container &container, Args &&...args) |
| |
| template<bool use_invoke = true, typename F , typename Tuple > |
| constexpr decltype(auto) | apply (F &&f, Tuple &&t) |
| |
| template<typename F , typename... Ts> |
| constexpr decltype(auto) | apply (F &&f, tuple< Ts... > &&t) |
| |
| template<typename F , typename... Ts> |
| constexpr decltype(auto) | apply (F &&f, tuple< Ts... > &t) |
| |
| template<typename F , typename... Ts> |
| constexpr decltype(auto) | apply (F &&f, tuple< Ts... > const &&t) |
| |
| template<typename F , typename... Ts> |
| constexpr decltype(auto) | apply (F &&f, tuple< Ts... > const &t) |
| |
| template<typename Func , typename... Ts> |
| constexpr decltype(auto) | apply (Func &&func, fwd_pack< Ts... > &&p) noexcept(std::is_nothrow_invocable_v< Func, Ts... >) |
| |
| template<typename Func , typename... Ts> |
| constexpr decltype(auto) | apply (tuple2< Ts... > &&tp, Func &&fn) |
| |
| template<typename Func , typename... Ts> |
| constexpr decltype(auto) | apply (tuple2< Ts... > &tp, Func &&fn) |
| |
| template<typename Func , typename... Ts> |
| constexpr decltype(auto) | apply (tuple2< Ts... > const &&tp, Func &&fn) |
| |
| template<typename Func , typename... Ts> |
| constexpr decltype(auto) | apply (tuple2< Ts... > const &tp, Func &&fn) |
| |
| template<typename Arg , typename Callable > |
| constexpr decltype(auto) | apply_string (Callable &&callable, daw::string_view str) |
| | Apply the reified string as the types specified as Arg to the Callable.
|
| |
| template<typename... Args, typename Callable > |
| constexpr decltype(auto) | apply_string (Callable &&callable, daw::string_view str, daw::string_view delemiter) |
| | Apply the reified string as the types specified as Args... to the Callable.
|
| |
| template<typename... Args, typename Callable , typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr> |
| constexpr decltype(auto) | apply_string (Callable &&callable, daw::string_view str, Splitter &&splitter) |
| | Apply the reified string as the types specified as Args... to the Callable.
|
| |
| template<typename Callable > |
| constexpr decltype(auto) | apply_string2 (Callable &&callable, daw::string_view str, daw::string_view delemiter) |
| | Apply the reified string as the types deducted from the Callable to the Callable. This may have unexpected results if strings are ot controlled.
|
| |
| template<typename Callable , typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr> |
| constexpr decltype(auto) | apply_string2 (Callable &&callable, daw::string_view str, Splitter &&splitter) |
| | Apply the reified string as the types deducted from the Callable to the Callable. This may have unexpected results if strings are ot controlled.
|
| |
| template<typename Integer , typename MaskBit , typename... MaskBits> |
| constexpr bool | are_set (Integer value, MaskBit mask_bit, MaskBits... mask_bits) noexcept |
| |
| template<typename T , typename Compare = std::equal_to<>, typename U = std::enable_if_t<std::is_array_v<remove_array_ref_t<T>>, remove_array_ref_t<T>>> |
| constexpr auto | array_cmp (T &&lhs, T &&rhs, Compare const &cmp=Compare{ }) |
| |
| template<typename From > |
| auto | as_char_array (From &&from) noexcept |
| |
| template<typename T > |
| constexpr std::add_const_t< T > & | as_const (T const &t) noexcept |
| |
| constexpr char | AsciiLower (char chr) noexcept |
| |
| template<typename CharType , typename Traits , typename Allocator > |
| constexpr auto | AsciiLower (std::basic_string< CharType, Traits, Allocator > str) noexcept |
| |
| constexpr char | AsciiUpper (char chr) noexcept |
| |
| template<typename CharType , typename Traits , typename Allocator > |
| constexpr auto | AsciiUpper (std::basic_string< CharType, Traits, Allocator > str) noexcept |
| |
| template<typename T , typename Rep , typename Period > |
| wait_status | atomic_wait_for (std::atomic< T > const *object, T const &old, std::chrono::duration< Rep, Period > const &rel_time, std::memory_order order=std::memory_order_acquire) |
| |
| template<typename T > |
| void | atomic_wait_if (std::atomic< T > const *object, Fn< bool(T)> auto &&predicate, std::memory_order order=std::memory_order_acquire) |
| |
| template<typename T , typename Rep , typename Period > |
| wait_status | atomic_wait_if_for (std::atomic< T > const *object, Fn< bool(T)> auto &&predicate, std::chrono::duration< Rep, Period > const &rel_time, std::memory_order order=std::memory_order_acquire) |
| |
| template<typename T , typename Clock , typename Duration > |
| wait_status | atomic_wait_if_until (std::atomic< T > const *object, Fn< bool(T)> auto &&predicate, std::chrono::time_point< Clock, Duration > const &timeout_time, std::memory_order order=std::memory_order_acquire) |
| |
| template<typename T , typename Clock , typename Duration > |
| wait_status | atomic_wait_until (std::atomic< T > const *object, T const &old, std::chrono::time_point< Clock, Duration > const &timeout_time, std::memory_order order=std::memory_order_acquire) |
| |
| template<typename T > |
| void | atomic_wait_value_equal (std::atomic< T > const *object, T const &desired_value, std::memory_order order=std::memory_order_acquire) |
| |
| template<typename T , typename Rep , typename Period > |
| wait_status | atomic_wait_value_equal_for (std::atomic< T > const *object, T const &desired_value, std::chrono::duration< Rep, Period > const &rel_time, std::memory_order order=std::memory_order_acquire) |
| |
| template<typename T , typename Clock , typename Duration > |
| wait_status | atomic_wait_value_equal_until (std::atomic< T > const *object, T const &desired_value, std::chrono::time_point< Clock, Duration > const &timeout_time, std::memory_order order=std::memory_order_acquire) |
| |
| template<typename Container > |
| | back_inserter (Container) -> back_inserter< Container > |
| |
| template<typename... Chars, std::enable_if_t< daw::traits::all_same_v< char, Chars... >, std::nullptr_t > = nullptr> |
| | basic_bounded_string (Chars...) -> basic_bounded_string< char, sizeof...(Chars)> |
| |
| template<typename CharT , size_t N> |
| | basic_bounded_string (CharT const (&)[N]) -> basic_bounded_string< CharT, N > |
| |
| template<typename Container > |
| constexpr auto | begin_at (Container &container, size_t n) noexcept(noexcept(std::begin(container))) -> decltype(std::begin(container)) |
| | Take iterator return from begin of a container and return the result of running next with n steps.
|
| |
| template<typename Container > |
| constexpr auto | begin_at (Container const &container, size_t n) noexcept(noexcept(std::cbegin(container))) -> decltype(std::cbegin(container)) |
| | Take iterator return from begin of a container and return the result of running next with n steps.
|
| |
| template<size_t Runs, char delem = '\n', typename Test , typename... Args> |
| DAW_ATTRIB_NOINLINE auto | bench_n_test (std::string const &title, Test &&test_callable, Args const &...args) |
| |
| template<size_t Runs, typename Function , typename... Args> |
| DAW_ATTRIB_NOINLINE std::vector< std::chrono::nanoseconds > | bench_n_test_json (Function &&func, Args &&...args) |
| |
| template<size_t Runs, typename Validator , typename Function , typename... Args> |
| DAW_ATTRIB_NOINLINE std::vector< std::chrono::nanoseconds > | bench_n_test_json_val (Validator &&validator, Function &&func, Args &&...args) |
| |
| template<size_t Runs, char delem = '\n', typename Test , typename... Args> |
| DAW_ATTRIB_NOINLINE auto | bench_n_test_mbs (std::string const &title, size_t bytes, Test &&test_callable, Args const &...args) |
| |
| template<size_t Runs, char delem = '\n', typename Validator , typename Function , typename... Args> |
| DAW_ATTRIB_NOINLINE std::array< double, Runs > | bench_n_test_mbs2 (std::string const &, size_t, Validator &&validator, Function &&func, Args const &...args) |
| |
| template<typename Test , typename... Args> |
| DAW_ATTRIB_NOINLINE auto | bench_test (std::string const &title, Test &&test_callable, Args &&...args) |
| |
| template<typename Test , typename... Args> |
| DAW_ATTRIB_NOINLINE auto | bench_test2 (std::string const &title, Test &&test_callable, size_t item_count, Args &&...args) |
| |
| template<typename F > |
| DAW_ATTRIB_NOINLINE double | benchmark (F &&func) |
| |
| template<typename ChildOrder = UnorderedWalk, typename T , typename Function > |
| void | bfs_walk (daw::graph_t< T > &graph, daw::node_id_t start_node_id, Function &&func, ChildOrder ord=ChildOrder{ }) |
| |
| template<typename ChildOrder = UnorderedWalk, typename T , typename Function > |
| void | bfs_walk (daw::graph_t< T > const &graph, daw::node_id_t start_node_id, Function &&func, ChildOrder ord=ChildOrder{ }) |
| |
| template<typename BiDirectionalIterator > |
| | bidirectional_counting_iterator (BiDirectionalIterator) -> bidirectional_counting_iterator< BiDirectionalIterator > |
| |
| template<std::size_t N, typename Invokable , typename... Args> |
| constexpr auto | bind_args_at (Invokable &&func, Args &&...args) |
| |
| template<typename Function , typename... Params> |
| | bind_front (Function, Params...) -> bind_front< Function, Params... > |
| |
| template<typename To , typename From > |
| To | bit_cast (From &&from) noexcept(std::is_nothrow_default_constructible_v< To >) |
| |
| template<typename T = deduced_type, typename Iterator , typename OutputIterator > |
| void | bit_cast_copy (Iterator first, Iterator last, OutputIterator first_out) |
| |
| template<typename T , typename Iterator , typename Function > |
| void | bit_cast_for_each (Iterator first, Iterator last, Function &&func) noexcept(noexcept(func(std::declval< T >()))) |
| |
| template<typename T , typename U = deduced_type, typename Iterator , typename OutputIterator , typename Function > |
| void | bit_cast_transform (Iterator first, Iterator last, OutputIterator first_out, Function &&func) |
| |
| template<typename Value > |
| constexpr std::size_t | bitcount (Value value) noexcept |
| |
| template<typename Value , typename... T> |
| constexpr std::size_t | bitcount (Value value, T... values) noexcept |
| |
| template<typename T , typename Allocator = std::allocator<T>, input_iterator InputIterator> |
| constexpr void | block_append_from (vector< T, Allocator > &v, InputIterator first, InputIterator last, std::size_t block_size=512) |
| |
| template<typename T , typename Allocator = std::allocator<T>, input_iterator InputIterator> |
| constexpr vector< T, Allocator > | block_create_from (InputIterator first, InputIterator last, std::size_t block_size=512) |
| |
| template<typename Key , typename Value , typename Hash = std::hash<Key>, size_t N> |
| | bounded_hash_map (std::pair< Key, Value > const (&&items)[N]) -> bounded_hash_map< Key, Value, N, Hash > |
| |
| template<typename Key , typename Value > |
| | bounded_hash_map_item_t (Key, Value) -> bounded_hash_map_item_t< Key, Value > |
| |
| constexpr void | breakpoint () noexcept |
| |
| template<typename T , typename... Args> |
| constexpr bool | can_extract (std::variant< Args... > &&var) noexcept |
| |
| template<typename T , typename... Args> |
| constexpr bool | can_extract (std::variant< Args... > const &var) noexcept |
| |
| template<typename IntegerDest , typename IntegerSource > |
| constexpr bool | can_fit (IntegerSource const value) noexcept |
| |
| template<typename T , bool AllowDownSignCast = false, typename U > |
| constexpr decltype(auto) | cast (U &&v) |
| |
| template<typename... ExpectedExceptions, typename Function , typename... Args> |
| auto | checked_from_code (Function func, Args &&...args) |
| |
| template<typename Iterator > |
| | chunk_iterator (Iterator, std::size_t) -> chunk_iterator< Iterator > |
| |
| template<typename T > |
| constexpr auto | cibegin (T &&container) noexcept |
| |
| template<typename T , size_t N> |
| constexpr auto | cibegin (T const (&container)[N]) noexcept |
| |
| template<typename T , size_t N> |
| constexpr auto | cibegin (T(&container)[N]) noexcept |
| |
| template<typename T > |
| constexpr auto | ciend (T &&container) noexcept |
| |
| template<typename T , size_t N> |
| constexpr auto | ciend (T const (&container)[N]) noexcept |
| |
| template<typename T , size_t N> |
| constexpr auto | ciend (T(&container)[N]) noexcept |
| |
| template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr> |
| DAW_ATTRIB_INLINE constexpr bool | cmp_equal (T t, U u) noexcept |
| |
| template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr> |
| DAW_ATTRIB_INLINE constexpr bool | cmp_greater (T t, U u) noexcept |
| |
| template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr> |
| DAW_ATTRIB_INLINE constexpr bool | cmp_greater_equal (T t, U u) noexcept |
| |
| template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr> |
| DAW_ATTRIB_INLINE constexpr bool | cmp_less (T t, U u) noexcept |
| |
| template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr> |
| DAW_ATTRIB_INLINE constexpr bool | cmp_less_equal (T t, U u) noexcept |
| |
| template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr> |
| DAW_ATTRIB_INLINE constexpr bool | cmp_not_equal (T t, U u) noexcept |
| |
| template<typename T , typename Storage , typename... Args> |
| T * | construct_at (Storage *p, Args &&...args) |
| |
| template<typename T , typename... Args> |
| constexpr T * | construct_at (T *p, Args &&...args) |
| |
| template<typename Destination , typename ExpectedArg > |
| constexpr decltype(auto) | construct_from (daw::string_view str) |
| | Contructs an object from the arguments specified in the string using a default delemiter of " ".
|
| |
| template<typename Destination , typename... ExpectedArgs> |
| constexpr decltype(auto) | construct_from (daw::string_view str, daw::string_view delemiter) |
| | Contructs an object from the arguments specified in the string.
|
| |
| template<typename Destination , typename... ExpectedArgs, typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr> |
| constexpr decltype(auto) | construct_from (daw::string_view str, Splitter &&splitter) |
| | Contructs an object from the arguments specified in the string.
|
| |
| template<typename Destination , typename... Args> |
| constexpr decltype(auto) | construct_from (std::tuple< Args... > &&args) noexcept(noexcept(daw::apply(construct_a< Destination >, std::move(args)))) |
| |
| template<typename Destination , typename... Args> |
| constexpr decltype(auto) | construct_from (std::tuple< Args... > const &args) noexcept(noexcept(daw::apply(construct_a< Destination >, args))) |
| |
| template<typename Container , typename Item > |
| constexpr bool | contains (Container const &container, Item const &item) noexcept |
| |
| template<ContiguousContainer Container> |
| | contiguous_view (Container &&c) -> contiguous_view< std::conditional_t< std::is_const_v< std::remove_reference_t< Container > >, daw::range_value_t< Container > const, daw::range_value_t< Container > > > |
| |
| template<ContiguousContainer Container, IntegralStd SizeT> |
| | contiguous_view (Container &&c, SizeT) -> contiguous_view< std::conditional_t< std::is_const_v< std::remove_reference_t< Container > >, daw::range_value_t< Container > const, daw::range_value_t< Container > > > |
| |
| template<Pointers P> |
| | contiguous_view (P, P) -> contiguous_view< std::remove_pointer_t< P > > |
| |
| template<Pointers P, IntegralStd SizeT> |
| | contiguous_view (P, SizeT) -> contiguous_view< std::remove_pointer_t< P > > |
| |
| template<typename T , std::size_t N> |
| | contiguous_view (T(&)[N]) -> contiguous_view< T > |
| |
| template<typename T , std::size_t N> |
| | contiguous_view (T(&)[N], std::size_t) -> contiguous_view< T > |
| |
| DAW_ATTRIB_NOINLINE void | contract_failure () |
| |
| template<typename T > |
| constexpr T | copy (T &&value) noexcept(std::is_nothrow_copy_constructible< T >::value) |
| |
| template<typename Iterator , typename OutputIterator > |
| constexpr OutputIterator | copy_n (Iterator first, std::size_t sz, OutputIterator out_it) noexcept |
| |
| template<typename T > |
| auto | copy_ptr_value (T const *const original) |
| |
| template<template< class, class > class Vector, typename T , typename A > |
| constexpr Vector< T, A > | copy_vector (Vector< T, A > const &container, std::size_t num_items) |
| |
template<std::size_t N, typename R >
requires ( std::ranges::range<R> and daw::traits::IntegerEnum<std::ranges::range_value_t<R>> ) |
| DAW_CPP23_CX_BITSET_FN auto | create_bitset_from_set_positions (R const &r) |
| |
| template<std::size_t N, daw::traits::IntegerEnum T> |
| DAW_CPP23_CX_BITSET_FN auto | create_bitset_from_set_positions (std::initializer_list< T > r) |
| |
| template<std::size_t N> |
| DAW_CPP23_CX_BITSET_FN auto | create_bitset_from_set_positions (traits::IntegerEnum auto... positions) |
| |
| template<typename Key , typename Value > |
| auto | create_hash_table (std::initializer_list< std::pair< Key, Value > > const &values) |
| |
| template<typename T , size_t N> |
| constexpr void | cswap (std::array< T, N > &lhs, std::array< T, N > &rhs) noexcept(std::conjunction_v< std::is_nothrow_move_assignable< T >, std::is_nothrow_move_constructible< T > >) |
| |
| template<typename T > |
| constexpr void | cswap (T &&lhs, T &&rhs) noexcept(std::conjunction_v< std::is_nothrow_move_assignable< T >, std::is_nothrow_move_constructible< T > >) |
| |
| template<typename Iterator1 , typename Iterator2 , typename OutputIterator > |
| constexpr OutputIterator | cxpr_copy (Iterator1 first_in, Iterator2 const last_in, OutputIterator first_out) |
| |
| template<typename Iterator1 , typename Iterator2 , typename OutputIterator > |
| constexpr OutputIterator | cxpr_move (Iterator1 first_in, Iterator2 const last_in, OutputIterator first_out) |
| |
| template<typename Container > |
| constexpr auto | data (Container &&c) |
| |
| template<typename Container > |
| constexpr auto | data_end (Container &&c) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_GET_WEAK_DEF (R(Params...) &&) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_GET_WEAK_DEF (R(Params...) &) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_GET_WEAK_DEF (R(Params...) const &&) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_GET_WEAK_DEF (R(Params...) const &) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_GET_WEAK_DEF (R(Params...)) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_SPEC (R(Params...) &&, sf_impl::cvref_t::RefRef, false) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_SPEC (R(Params...) &&noexcept, sf_impl::cvref_t::RefRef, true) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_SPEC (R(Params...) &, sf_impl::cvref_t::Ref, false) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_SPEC (R(Params...) &noexcept, sf_impl::cvref_t::Ref, true) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_SPEC (R(Params...) const &&, sf_impl::cvref_t::ConstRefRef, false) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_SPEC (R(Params...) const &&noexcept, sf_impl::cvref_t::ConstRefRef, true) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_SPEC (R(Params...) const &, sf_impl::cvref_t::ConstRef, false) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_SPEC (R(Params...) const &noexcept, sf_impl::cvref_t::ConstRef, true) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_SPEC (R(Params...) const noexcept, sf_impl::cvref_t::Const, true) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_SPEC (R(Params...) const, sf_impl::cvref_t::Const, false) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_SPEC (R(Params...) noexcept, sf_impl::cvref_t::None, true) |
| |
| | DAW_DETAIL_SHARED_FUNCTION_SPEC (R(Params...), sf_impl::cvref_t::None, false) |
| |
| | DAW_DETAIL_WEAK_SHARED_FUNCTION_SPEC (R(Params...) &&, sf_impl::cvref_t::RefRef, false) |
| |
| | DAW_DETAIL_WEAK_SHARED_FUNCTION_SPEC (R(Params...) &&noexcept, sf_impl::cvref_t::RefRef, true) |
| |
| | DAW_DETAIL_WEAK_SHARED_FUNCTION_SPEC (R(Params...) &, sf_impl::cvref_t::Ref, false) |
| |
| | DAW_DETAIL_WEAK_SHARED_FUNCTION_SPEC (R(Params...) &noexcept, sf_impl::cvref_t::Ref, true) |
| |
| | DAW_DETAIL_WEAK_SHARED_FUNCTION_SPEC (R(Params...) const &&, sf_impl::cvref_t::ConstRefRef, false) |
| |
| | DAW_DETAIL_WEAK_SHARED_FUNCTION_SPEC (R(Params...) const &&noexcept, sf_impl::cvref_t::ConstRefRef, true) |
| |
| | DAW_DETAIL_WEAK_SHARED_FUNCTION_SPEC (R(Params...) const &, sf_impl::cvref_t::ConstRef, false) |
| |
| | DAW_DETAIL_WEAK_SHARED_FUNCTION_SPEC (R(Params...) const &noexcept, sf_impl::cvref_t::ConstRef, true) |
| |
| | DAW_DETAIL_WEAK_SHARED_FUNCTION_SPEC (R(Params...) const noexcept, sf_impl::cvref_t::Const, true) |
| |
| | DAW_DETAIL_WEAK_SHARED_FUNCTION_SPEC (R(Params...) const, sf_impl::cvref_t::Const, false) |
| |
| | DAW_DETAIL_WEAK_SHARED_FUNCTION_SPEC (R(Params...) noexcept, sf_impl::cvref_t::None, true) |
| |
| | DAW_DETAIL_WEAK_SHARED_FUNCTION_SPEC (R(Params...), sf_impl::cvref_t::None, false) |
| |
| | DAW_MAKE_REQ_TRAIT (can_be_bounded_string, daw::bounded_string{ std::declval< T >() }) |
| |
| template<class T > |
| constexpr auto | decay_copy (T &&v) noexcept(is_nothrow_convertible_v< T, std::decay_t< T > >) -> std::enable_if_t< std::is_convertible_v< T, std::decay_t< T > >, std::decay_t< T > > |
| |
| void | default_contract_failure () |
| |
| template<typename... > |
| void | deleted ()=delete |
| |
| template<typename T , typename Function , typename ChildOrder = UnorderedWalk> |
| void | dfs_walk (daw::graph_t< T > &graph, daw::node_id_t start_node_id, Function &&func, ChildOrder ord=ChildOrder{ }) |
| |
| template<typename T , typename Function , typename ChildOrder = UnorderedWalk> |
| void | dfs_walk (daw::graph_t< T > const &graph, daw::node_id_t start_node_id, Function &&func, ChildOrder ord=ChildOrder{ }) |
| |
| template<typename Iterator > |
| constexpr ptrdiff_t | distance (Iterator first, Iterator second) noexcept(noexcept(cpp_17_details::distance_impl(first, second, typename std::iterator_traits< Iterator >::iterator_category{ }))) |
| | Calculate distance between iterators.
|
| |
| template<class T > |
| DAW_ATTRIB_INLINE void | do_not_optimize (T const &value) |
| |
| template<typename... Values, std::enable_if_t<(sizeof...(Values) !=1), std::nullptr_t > = nullptr> |
| DAW_ATTRIB_INLINE void | do_not_optimize (Values &&...values) |
| |
| template<typename... Args> |
| void | dump (Args &&...args) |
| |
| constexpr bool | empty_range (Range auto &&r) |
| |
| template<typename Container > |
| constexpr auto | end_inserter (Container &c) |
| |
| template<typename Container > |
| | end_inserter_iterator (Container) -> end_inserter_iterator< Container > |
| |
| template<typename Index = std::size_t, typename Tp > |
| constexpr enumerated_tuple_t< Tp, Index > | enumerate_tuple (Tp &&tp) |
| |
| template<typename T > |
| constexpr utility_details::EqualToImpl< T > | equal_to (T value) |
| |
| template<typename T , typename Allocator > |
| constexpr vector< T, Allocator >::size_type | erase (vector< T, Allocator > &c, auto const &v) |
| |
| template<typename T , typename Allocator > |
| constexpr vector< T, Allocator >::size_type | erase_if (vector< T, Allocator > &c, auto pred) |
| |
| template<typename T , typename U = T> |
| DAW_ATTRIB_INLINE constexpr T | exchange (T &obj, U &&new_value) |
| |
| template<typename... Ts> |
| | expander (Ts...) -> expander< Ts... > |
| |
| template<typename Result , typename Function , typename... Args> |
| expected_t< Result > | expected_from_code (Function &&func, Args &&...args) |
| |
| template<typename Function , typename... Args> |
| auto | expected_from_code (Function &&func, Args &&...args) |
| |
| template<typename Result > |
| expected_t< Result > | expected_from_exception () |
| |
| template<typename Result > |
| expected_t< Result > | expected_from_exception (std::exception_ptr ptr) |
| |
| template<typename Bool > |
| DAW_ATTRIB_NOINLINE constexpr void | expecting (Bool const &expected_result) |
| |
| template<typename T , typename U > |
| DAW_ATTRIB_NOINLINE constexpr void | expecting (T &&expected_result, U &&result) |
| |
| template<typename Exception = std::exception, typename Expression , typename Predicate = benchmark_impl::always_true, std::enable_if_t< std::is_invocable_v< Predicate, Exception >, std::nullptr_t > = nullptr> |
| DAW_ATTRIB_NOINLINE void | expecting_exception (Expression &&expression, Predicate &&pred=Predicate{ }) |
| |
| template<typename Bool , typename String > |
| DAW_ATTRIB_NOINLINE constexpr void | expecting_message (Bool &&expected_result, String &&message) |
| |
| template<typename T > |
| constexpr auto | extract_from_container (T &container) |
| |
| template<typename Iterator1 , typename Iterator2 , typename Pred > |
| std::vector< Iterator1 > | find_all_where (Iterator1 first, Iterator2 const last, Pred predicate) |
| |
| template<typename T , typename Pred > |
| auto | find_all_where (T const &values, Pred predicate) |
| |
| template<typename Iterator , typename Filter > |
| | find_iterator (Iterator, Filter) -> find_iterator< Iterator, Iterator, Filter > |
| |
| template<typename Iterator , typename IteratorLast , typename Filter > |
| | find_iterator (Iterator, IteratorLast, Filter) -> find_iterator< Iterator, IteratorLast, Filter > |
| |
| template<typename Iterator , typename IteratorLast , typename Filter > |
| | find_one_iterator (Iterator, IteratorLast, Filter) -> find_one_iterator< Iterator, IteratorLast, Filter > |
| |
| template<typename Iterator > |
| | fixed_array (Iterator, std::size_t) -> fixed_array< typename std::iterator_traits< Iterator >::value_type > |
| |
| template<typename... Ts> |
| | fixed_array (std::in_place_t, Ts...) -> fixed_array< std::common_type_t< Ts... > > |
| |
| template<typename T , typename... Ts> |
| | fixed_array (std::in_place_type_t< T >, Ts...) -> fixed_array< T > |
| |
| template<typename T > |
| | fixed_array (std::size_t, T) -> fixed_array< T > |
| |
| template<typename Float , std::enable_if_t< std::is_floating_point_v< Float >, std::nullptr_t > = nullptr> |
| constexpr Float | float_abs (Float f) |
| |
| template<typename T > |
| constexpr decltype(auto) | fmt_any (T &&v) |
| |
| template<Range R> |
| | fmt_range (R) -> fmt_range< R > |
| |
| template<Range R, typename CharT > |
| | fmt_range (R, CharT const *) -> fmt_range< R, CharT > |
| |
| template<Range R, typename CharT > |
| | fmt_range (R, CharT const *, CharT const *, CharT const *) -> fmt_range< R, CharT > |
| |
| template<typename T > |
| | fmt_tuple (T) -> fmt_tuple< T > |
| |
| template<typename T , typename CharT > |
| | fmt_tuple (T, CharT const *) -> fmt_tuple< T, CharT > |
| |
| template<typename T , typename CharT > |
| | fmt_tuple (T, CharT const *, CharT const *, CharT const *) -> fmt_tuple< T, CharT > |
| |
| template<fnv1a_uint_t N> |
| constexpr fnv1a_uint_t | fnv1a_hash (char const (&ptr)[N]) noexcept |
| |
| constexpr fnv1a_uint_t | fnv1a_hash (char const *ptr) noexcept |
| |
| template<typename CharT > |
| constexpr fnv1a_uint_t | fnv1a_hash (CharT const *ptr, std::size_t len) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr size_t | fnv1a_hash (daw::basic_bounded_string< CharT, Capacity > const &str) noexcept |
| |
| template<typename Integer , std::enable_if_t< std::is_integral_v< Integer >, std::nullptr_t > = nullptr> |
| constexpr fnv1a_uint_t | fnv1a_hash (Integer value) noexcept |
| |
| template<typename StringViewLike , std::enable_if_t< traits_is_sv::is_string_view_like_v< StringViewLike >, std::nullptr_t > = nullptr> |
| fnv1a_uint_t | fnv1a_hash (StringViewLike &&sv) |
| |
| template<typename T > |
| void | force_evaluation (T &value) |
| |
| template<typename T > |
| void | force_evaluation (T const &value) |
| |
| template<typename... Ts> |
| constexpr tuple< Ts &&... > | forward_as_tuple (Ts &&...ts) noexcept |
| |
| template<typename... Ts> |
| constexpr tuple2< Ts... > | forward_as_tuple2 (Ts &&...args) |
| |
| template<typename ForwardIterator > |
| | forward_counting_iterator (ForwardIterator) -> forward_counting_iterator< ForwardIterator > |
| |
| template<class T , class U > |
| constexpr auto && | forward_like (U &&x) noexcept |
| |
| template<typename T > |
| DAW_ATTRIB_INLINE constexpr decltype(auto) | forward_lvalue (T &&r) |
| |
| template<typename... Ts> |
| constexpr auto | forward_nonrvalue_as_tuple (Ts &&...values) |
| | Forwards arguments but stores rvalues. This allows use to prevent dangling ref's.
|
| |
| template<typename... Ts> |
| constexpr auto | forward_nontemp_as_tuple (Ts &&...values) |
| |
| template<std::size_t Idx, typename... Ts> |
| constexpr decltype(auto) | forward_nth_pack_element (Ts &&...values) |
| |
template<typename T >
requires requires { daw::from_string_trait::from_string_t<T>{}; } |
| constexpr auto | from_string (daw::tag_t< T >, daw::string_view sv) |
| |
| template<typename Function > |
| | function_iterator (Function) -> function_iterator< Function > |
| |
| template<typename... Ts> |
| | fwd_pack (Ts &&...) -> fwd_pack< Ts &&... > |
| |
| template<size_t HashBytes = sizeof( genhash_uint_t ), std::size_t N> |
| constexpr auto | generic_hash (char const (&ptr)[N]) noexcept |
| |
| template<size_t HashSize = sizeof( size_t ), typename CharT , size_t Capacity> |
| constexpr size_t | generic_hash (daw::basic_bounded_string< CharT, Capacity > const &str) noexcept |
| |
| template<size_t HashSize = sizeof( size_t ), typename CharT , size_t Capacity> |
| constexpr size_t | generic_hash (daw::basic_bounded_string< CharT, Capacity > sv) noexcept |
| |
| template<size_t HashBytes = sizeof( genhash_uint_t ), typename Iterator , typename IteratorL > |
| constexpr auto | generic_hash (Iterator first, IteratorL const last) noexcept |
| |
| template<size_t HashBytes = sizeof( genhash_uint_t ), typename Iterator > |
| constexpr auto | generic_hash (Iterator first, std::size_t const len) noexcept |
| |
| template<size_t HashBytes = sizeof( genhash_uint_t ), typename StringViewLike , std::enable_if_t< traits_is_sv::is_string_view_like_v< StringViewLike >, std::nullptr_t > = nullptr> |
| auto | generic_hash (StringViewLike const &&sv) noexcept |
| |
| template<size_t HashBytes = sizeof( genhash_uint_t ), typename T , std::enable_if_t< std::is_integral_v< T >, std::nullptr_t > = nullptr> |
| constexpr auto | generic_hash (T const value) noexcept |
| |
| template<std::size_t Idx, typename FwdPack DAW_ENABLEIF> |
| constexpr decltype(auto) | get (FwdPack &&p) |
| |
| template<typename... Args> |
| constexpr auto | get (std::tuple< Args... > &tp, size_t index) noexcept |
| |
| template<typename... Args> |
| constexpr auto | get (std::tuple< Args... > const &tp, size_t index) noexcept |
| |
| template<std::size_t Index, typename Ts > |
| constexpr Ts && | get (tuple2_impl::leaf< Index, Ts, false > &&tp) |
| |
| template<std::size_t Index, typename Ts > |
| constexpr Ts & | get (tuple2_impl::leaf< Index, Ts, false > &tp) |
| |
| template<std::size_t Index, typename Ts > |
| constexpr Ts const && | get (tuple2_impl::leaf< Index, Ts, false > const &&tp) |
| |
| template<std::size_t Index, typename Ts > |
| constexpr Ts const & | get (tuple2_impl::leaf< Index, Ts, false > const &tp) |
| |
| template<std::size_t Index, typename Ts > |
| constexpr Ts && | get (tuple2_impl::leaf< Index, Ts, true > &&tp) |
| |
| template<std::size_t Index, typename Ts > |
| constexpr Ts & | get (tuple2_impl::leaf< Index, Ts, true > &tp) |
| |
| template<std::size_t Index, typename Ts > |
| constexpr Ts const && | get (tuple2_impl::leaf< Index, Ts, true > const &&tp) |
| |
| template<std::size_t Index, typename Ts > |
| constexpr Ts const & | get (tuple2_impl::leaf< Index, Ts, true > const &tp) |
| |
| template<std::size_t N, typename... Ts> |
| constexpr decltype(auto) | get (tuple< Ts... > &&tp) |
| |
| template<std::size_t N, typename... Ts> |
| constexpr decltype(auto) | get (tuple< Ts... > &tp) |
| |
| template<std::size_t N, typename... Ts> |
| constexpr decltype(auto) | get (tuple< Ts... > const &tp) |
| |
| template<size_t N, typename... T> |
| constexpr decltype(auto) | get (zip_iterator< T... > &zi) noexcept |
| |
| template<size_t N, typename... T> |
| constexpr decltype(auto) | get (zip_iterator< T... > const &zi) noexcept |
| |
| template<unsigned N> |
| constexpr UInt16 | get_bit (UInt16 value) |
| |
| template<unsigned N> |
| constexpr UInt32 | get_bit (UInt32 value) |
| |
| template<unsigned N> |
| constexpr UInt64 | get_bit (UInt64 value) |
| |
| template<unsigned N> |
| constexpr UInt8 | get_bit (UInt8 value) |
| |
| template<typename Integer , typename Bit , typename... Bits> |
| constexpr Integer | get_bits (Integer i, Bit b, Bits... bs) noexcept |
| | get value with all bits but those specified masked out
|
| |
| template<typename T , std::size_t Alignment = alignof( T )> |
| T * | get_buffer (std::size_t count) noexcept |
| | aligned_alloc is not in clang-cl 13 with vs2022
|
| |
| template<typename T > |
| constexpr T | get_left_mask (size_t left_zero_bits) noexcept |
| |
| template<std::size_t Idx, typename Variant > |
| constexpr decltype(auto) | get_nt (Variant &&var) |
| |
| template<typename T > |
| constexpr T | get_right_mask (size_t right_zero_bits) noexcept |
| |
| template<typename OutputIterator > |
| constexpr OutputIterator | hex (char c, OutputIterator it_out) noexcept |
| |
| template<size_t N, typename OutputIterator > |
| constexpr OutputIterator | hex (char const (&str)[N], OutputIterator first_out) noexcept |
| |
| template<typename OutputIterator > |
| constexpr OutputIterator | hex (char const *str, std::size_t len, OutputIterator first_out) noexcept |
| |
| template<typename ForwardIterator1 , typename ForwardIterator2 , typename OutputIterator , std::enable_if_t< std::is_integral_v< typename std::iterator_traits< ForwardIterator1 >::value_type >, std::nullptr_t > = nullptr> |
| constexpr OutputIterator | hex (ForwardIterator1 first_in, ForwardIterator2 const last_in, OutputIterator first_out) noexcept |
| |
| template<typename ForwardIterator1 , typename ForwardIterator2 , typename OutputIterator , std::enable_if_t< not std::is_integral_v< typename std::iterator_traits< ForwardIterator1 >::value_type >, std::nullptr_t > = nullptr> |
| OutputIterator | hex (ForwardIterator1 first_in, ForwardIterator2 const last_in, OutputIterator first_out) noexcept |
| |
| template<typename T , typename OutputIterator , std::enable_if_t< std::is_integral_v< T >, std::nullptr_t > = nullptr> |
| constexpr OutputIterator | hex (T const &val, OutputIterator it_out) noexcept |
| |
| template<typename T , typename OutputIterator , std::enable_if_t< not std::is_integral_v< T >, std::nullptr_t > = nullptr> |
| OutputIterator | hex (T const &val, OutputIterator it_out) noexcept |
| |
| template<typename OutputIterator > |
| constexpr OutputIterator | hex_lc (char c, OutputIterator it_out) noexcept |
| |
| template<typename T > |
| constexpr auto | ibegin (T &&container) noexcept |
| |
| template<typename T , size_t N> |
| constexpr auto | ibegin (T const (&container)[N]) noexcept |
| |
| template<typename T , size_t N> |
| constexpr auto | ibegin (T(&container)[N]) noexcept |
| |
| template<typename T > |
| constexpr auto | iend (T &&container) noexcept |
| |
| template<typename T , size_t N> |
| constexpr auto | iend (T const (&container)[N]) noexcept |
| |
| template<typename T , size_t N> |
| constexpr auto | iend (T(&container)[N]) noexcept |
| |
| template<typename R , typename T , std::enable_if_t< daw::is_integral_v< R > and daw::is_integral_v< T >, std::nullptr_t > = nullptr> |
| DAW_ATTRIB_INLINE constexpr bool | in_range (T t) noexcept |
| |
| template<typename Value , typename LowerBound , typename UpperBound > |
| constexpr bool | in_range (Value &&value, LowerBound &&lower, UpperBound &&upper) noexcept(noexcept(lower<=value &&value< upper)) |
| | Checks if value is in the range [lower, upper)
|
| |
| template<typename Container , typename Item > |
| constexpr auto | index_of (Container const &container, Item const &item) noexcept |
| |
| template<typename Iterator > |
| | InputIterator (Iterator) -> InputIterator< typename std::iterator_traits< Iterator >::value_type > |
| |
| template<typename Container > |
| | InputRange (Container) -> InputRange< std::remove_reference_t< decltype(*std::begin(std::declval< Container >()))> > |
| |
| template<typename Iterator > |
| | InputRange (Iterator, Iterator) -> InputRange< typename std::iterator_traits< Iterator >::value_type > |
| |
| template<typename Container , typename Allocator , typename Pointer > |
| constexpr void | insert_into_container (Container &vec, Pointer *buff, Allocator alloc, std::size_t capacity, std::size_t size) |
| |
| template<typename Container > |
| constexpr auto | inserter (Container &c) |
| |
| template<typename F , typename... Args, std::enable_if_t< sizeof...(Args) !=1 or((not is_reference_wrapper_v< Args >) and ...), std::nullptr_t > = nullptr> |
| constexpr decltype(auto) | invoke (F &&f, Args &&...args) noexcept(std::is_nothrow_invocable_v< F, Args... >) |
| |
| template<typename F , typename Arg , typename... Args> |
| constexpr decltype(auto) | invoke (F &&f, std::reference_wrapper< Arg > arg, std::reference_wrapper< Args >... args) noexcept(std::is_nothrow_invocable_v< F, Args... >) |
| |
| | iota_iterator () -> iota_iterator< int > |
| |
| template<typename T , typename... Step> |
| | iota_iterator (T, Step...) -> iota_iterator< T > |
| |
| | iota_range () -> iota_range< int > |
| |
| template<typename T , typename... EndStep> |
| | iota_range (T, EndStep...) -> iota_range< T > |
| |
| constexpr bool | is_space (char chr) noexcept |
| |
| template<typename R > |
| constexpr auto | iter_last (R &&r) |
| |
| template<typename ForwardIterator1 , typename ForwardIterator2 > |
| constexpr void | iter_swap (ForwardIterator1 lhs, ForwardIterator2 rhs) noexcept(std::conjunction_v< std::is_nothrow_move_assignable< decltype(*lhs)>, std::is_nothrow_move_assignable< decltype(*rhs)> >) |
| |
| template<typename Container > |
| | iter_view (Container) -> iter_view< typename Container::iterator > |
| |
| template<typename ForwardIterator , typename Last > |
| | iter_view (ForwardIterator, Last) -> iter_view< ForwardIterator, Last > |
| |
| template<typename T , std::size_t N> |
| | iter_view (T(&&)[N]) -> iter_view< T * > |
| |
| template<typename T , std::size_t N> |
| | iter_view (T(&)[N]) -> iter_view< T * > |
| |
| template<typename T = make_array_impl::unspecified_type, typename... Args, std::enable_if_t< not std::is_same_v< T, void >, std::nullptr_t > = nullptr> |
| constexpr auto | make_array (Args &&...args) |
| |
| template<typename T , size_t N> |
| constexpr auto | make_array (T const (&&arry)[N]) |
| |
| template<typename Iterator > |
| constexpr auto | make_bit_iterator (Iterator &&it) |
| | Create a bit_iterator with supplied bit.
|
| |
| template<typename BitQueueLSB = bit_queue_source_native_endian, typename InputIteratorF , typename InputIteratorL > |
| constexpr auto | make_bit_stream (InputIteratorF first, InputIteratorL last) noexcept |
| |
| template<typename Key , typename Value , typename Hash = std::hash<Key>, size_t N> |
| DAW_CONSTEVAL auto | make_bounded_hash_map (std::pair< Key, Value > const (&items)[N]) |
| |
| template<typename Key , typename Hash = std::hash<Key>, size_t N> |
| constexpr auto | make_bounded_hash_set (Key const (&items)[N]) noexcept |
| |
| template<size_t Capacity = 100, typename CharT , size_t N> |
| constexpr daw::basic_bounded_string< CharT, Capacity > | make_bounded_string (CharT const (&str)[N]) |
| |
| template<size_t Capacity = 100, typename Container > |
| constexpr auto | make_bounded_string (Container const &v) noexcept -> basic_bounded_string< typename Container::value_type, Capacity > |
| |
| template<size_t Capacity = 100, typename CharT > |
| constexpr auto | make_bounded_string_it (CharT const *first, CharT const *last) noexcept |
| |
| template<size_t Capacity = 100, typename Iterator , typename CharT = DAW_TYPEOF( *std::declval<Iterator>( ) )> |
| constexpr auto | make_bounded_string_it (Iterator first, Iterator last) noexcept |
| |
| template<typename Function , std::enable_if_t< not std::is_function_v< std::remove_reference_t< Function > >, std::nullptr_t > = nullptr> |
| constexpr decltype(auto) | make_callable (Function &&func) noexcept |
| |
| template<typename Function , std::enable_if_t< std::is_function_v< Function >, std::nullptr_t > = nullptr> |
| constexpr auto | make_callable (Function *func) noexcept |
| |
| template<typename Result , typename... Exceptions, typename Function > |
| constexpr checked_function_t< Function, Result, Exceptions... > | make_checked_function (Function &&func) noexcept |
| |
| template<typename IteratorFirst , typename IteratorLast > |
| auto | make_checked_iterator_proxy (IteratorFirst first, IteratorLast last, bool CheckIncrement=true, bool CheckDecrement=true, bool CheckDereference=true) |
| |
| template<typename Container > |
| constexpr auto | make_circular_iterator (Container &container) noexcept |
| |
| template<typename Container , typename Iterator > |
| constexpr auto | make_circular_iterator (Container &container, Iterator it) noexcept |
| |
| template<typename T > |
| constexpr auto | make_const_random_iterator (T *const ptr) noexcept |
| |
| template<typename T , typename... Args> |
| copiable_unique_ptr< T > | make_copiable_unique_ptr (Args &&...args) noexcept(std::is_nothrow_constructible_v< T, Args... >) |
| |
| template<typename Value , size_t HashSize = sizeof( size_t ), typename... Keys> |
| constexpr auto | make_fixed_lookup (Keys &&...keys) noexcept |
| |
| template<size_t N> |
| constexpr auto | make_formatter (char const (&str)[N]) |
| |
| template<class T , class Tuple > |
| constexpr T | make_from_tuple2 (Tuple &&t) |
| |
| template<typename L > |
| constexpr function_traits_t< L > | make_function (L l) noexcept |
| |
| template<typename ReturnType , typename... Args> |
| std::function< ReturnType(Args...)> | make_function (ReturnType(*p)(Args...)) |
| |
| template<typename ReturnType , typename... Args> |
| std::function< daw::traits::root_type_t< ReturnType >(daw::traits::root_type_t< Args >...)> | make_function (ReturnType(*p)(Args...)) |
| |
| template<typename ReturnType , typename... Args, typename ClassType > |
| std::function< ReturnType(Args...)> | make_function (ReturnType(ClassType::*p)(Args...)) |
| |
| template<typename ReturnType , typename... Args, typename ClassType > |
| std::function< daw::traits::root_type_t< ReturnType >(daw::traits::root_type_t< Args >...)> | make_function (ReturnType(ClassType::*p)(Args...)) |
| |
| template<typename ReturnType , typename... Args, class T > |
| auto | make_function (T &&t) -> std::function< decltype(ReturnType(t(std::declval< Args >()...)))(Args...)> |
| |
| template<typename Function > |
| constexpr auto | make_function_iterator (Function &&func) |
| | Create a function_iterator with supplied function.
|
| |
| template<typename R = void, typename Function , typename... Functions> |
| constexpr function_table_t< R, Function, Functions... > | make_function_table (Function fn, Functions... fns) |
| |
| template<typename Arg , typename... Args> |
| auto | make_initializer_list (Arg &&arg, Args &&...args) |
| |
| template<typename Bit , typename... Bits> |
| constexpr auto | make_mask (Bit bit, Bits... bits) noexcept |
| |
| template<typename T , typename... Args> |
| DAW_CPP20_CX_ALLOC auto | make_maybe_unique (Args &&...args) -> std::enable_if_t< not std::is_array_v< T >, maybe_unique_ptr< T > > |
| |
| template<typename T > |
| DAW_CPP20_CX_ALLOC auto | make_maybe_unique (std::size_t count) -> std::enable_if_t< std::is_array_v< T >, maybe_unique_ptr< T > > |
| |
| template<typename T , typename... Elements> |
| DAW_CPP20_CX_ALLOC auto | make_maybe_unique_array (Elements &&...elements) -> std::enable_if_t< std::is_array_v< T >, maybe_unique_ptr< T > > |
| |
| template<typename T > |
| DAW_CPP20_CX_ALLOC auto | make_maybe_unique_for_overwrite () -> std::enable_if_t< not std::is_array_v< T >, maybe_unique_ptr< T > > |
| |
| template<typename Iterator > |
| constexpr std::move_iterator< Iterator > | make_move_iterator (Iterator &&i) |
| |
| template<typename T , typename... Args> |
| auto | make_optional_poly (Args &&...args) |
| |
| template<typename OutputStream > |
| constexpr function_iterator< osi_impl::osi_callable< OutputStream > > | make_output_stream_iterator (OutputStream &strm) |
| |
| template<typename Hasher , typename Key , typename Value , size_t N> |
| constexpr auto | make_perfect_hash_table (std::pair< Key, Value > const (&data)[N]) |
| |
| template<typename IntType , typename Result = std::vector<IntType>> |
| Result | make_random_data (std::size_t count, IntType a=lowest_value< IntType >, IntType b=max_value< IntType >) |
| |
| template<typename T > |
| constexpr auto | make_random_iterator (T *const ptr) noexcept |
| |
| template<typename Iterator > |
| constexpr auto | make_range (Iterator first, Iterator last) noexcept |
| |
| template<typename T , typename... Args> |
| DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_single< T > | make_rc_ptr (Args &&...args) |
| |
| template<typename T > |
| DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_array< T > | make_rc_ptr (std::size_t size) |
| |
| template<typename T , typename... Args> |
| DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_single< T > | make_rc_ptr_for_overwrite (Args &&...)=delete |
| |
| template<typename T > |
| DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_array< T > | make_rc_ptr_for_overwrite (std::size_t size) |
| |
| template<typename Iterator > |
| constexpr reverse_iterator< Iterator > | make_reverse_iterator (Iterator i) |
| |
| template<typename Graph , typename Compare = daw::graph_alg_impl::NoSort> |
| auto | make_reverse_topological_sorted_range (Graph &&g, Compare c=Compare{ }) |
| |
| template<typename L > |
| constexpr auto | make_root_function (L l) noexcept |
| |
| template<typename ReturnType , typename... Args, class T > |
| auto | make_root_function (T &&t) -> std::function< decltype(daw::traits::root_type_t< ReturnType >(t(std::declval< daw::traits::root_type_t< Args > >()...)))(Args...)> |
| |
| template<typename SanitizeFunction , typename charT , typename traits = std::char_traits<charT>, typename Alloc = std::allocator<charT>> |
| auto | make_safe_string (charT const *const unsafe_cstring, SanitizeFunction &&sanitize_function) |
| |
| template<typename SanitizeFunction , typename charT , typename traits , typename Alloc > |
| auto | make_safe_string (std::basic_string< charT, traits, Alloc > unsafe_string, SanitizeFunction &&sanitize_function) |
| |
| template<typename... Args, typename Compare = std::less<>> |
| auto | make_sorted_insert_iterator (std::deque< Args... > &c, Compare compare=Compare{ }) |
| |
| template<typename... Args, typename Compare = std::less<>> |
| decltype(auto) | make_sorted_insert_iterator (std::list< Args... > &c, Compare compare=Compare{ }) |
| |
| template<typename... Args, typename Compare = std::less<>> |
| auto | make_sorted_insert_iterator (std::vector< Args... > &c, Compare compare=Compare{ }) |
| |
| template<typename CharT , typename Traits , typename Allocator > |
| constexpr auto | make_split_it (std::basic_string< CharT, Traits, Allocator > &str, CharT divider) noexcept |
| |
| template<typename String , typename Splitter , daw::required< impl::is_splitter_v< Splitter, String > > = nullptr> |
| constexpr auto | make_split_it (String &sv, Splitter &&splitter) noexcept |
| |
| template<typename ReturnType , typename... Args, typename ClassType > |
| std::function< ReturnType(Args...)> | make_std_function (ReturnType(ClassType::*p)(Args...)) |
| |
| template<typename... Ts> |
| std::array< std::string, sizeof...(Ts)> | make_string_array (Ts &&...t) |
| |
| template<typename Graph , typename Compare = daw::graph_alg_impl::NoSort> |
| auto | make_topological_sorted_range (Graph &&g, Compare c=Compare{ }) |
| |
| template<typename... Ts> |
| constexpr tuple< make_tuple_details::unwrap_decay_t< Ts >... > | make_tuple (Ts &&...args) |
| |
| template<typename T , typename... Args> |
| DAW_CPP20_CX_ALLOC auto | make_unique (Args &&...args) -> std::enable_if_t< not std::is_array_v< T >, unique_ptr< T > > |
| |
| template<typename T > |
| DAW_CPP20_CX_ALLOC auto | make_unique (std::size_t count) -> std::enable_if_t< std::is_array_v< T >, unique_ptr< T > > |
| |
| template<typename T , typename... Elements> |
| DAW_CPP20_CX_ALLOC auto | make_unique_array (Elements &&...elements) -> std::enable_if_t< std::is_array_v< T >, unique_ptr< T > > |
| |
| template<typename T > |
| DAW_CPP20_CX_ALLOC auto | make_unique_for_overwrite () -> std::enable_if_t< not std::is_array_v< T >, unique_ptr< T > > |
| |
| template<typename Function > |
| constexpr auto | make_void_function (Function &&func) noexcept(noexcept(traits_details::void_function< Function >(DAW_FWD(func)))) |
| |
| template<typename... Containers> |
| zip_container< Containers... > | make_zipcontainer (Containers &&...args) |
| |
| template<typename T > |
| constexpr T | mask_lsb (size_t bit_count) noexcept |
| |
| template<typename T > |
| constexpr T | mask_msb (size_t bit_count) noexcept |
| |
| template<typename T , typename... Ts> |
| constexpr auto() | max (T const &val1, Ts const &...vs) noexcept |
| |
| template<typename T , typename Compare = math_impl::less> |
| constexpr decltype(auto) | max_comp (T &&lhs, T &&rhs, Compare &&comp=Compare{ }) |
| |
| template<typename T , typename... Ts> |
| constexpr auto() | min (T const &val1, Ts const &...vs) noexcept |
| |
| template<typename T , typename Compare = math_impl::less> |
| constexpr decltype(auto) | min_comp (T &&lhs, T &&rhs, Compare &&comp=Compare{ }) |
| |
| template<typename T > |
| constexpr daw::traits::remove_reference_t< T > && | move (T &&value) noexcept |
| | Convert a value to an rvalue.
|
| |
| template<typename Iterator , typename OutputIterator > |
| constexpr OutputIterator | move_n (Iterator first, std::size_t sz, OutputIterator out_it) noexcept |
| |
| template<typename T > |
| | move_only (T) -> move_only< T > |
| |
| template<typename T , typename Compare = daw::graph_alg_impl::NoSort> |
| void | mst (daw::graph_t< T > &graph, Compare=Compare{ }) |
| |
| template<typename T > |
| | mutable_capture (T) -> mutable_capture< T > |
| |
| template<typename Integer , typename... Ts, typename T > |
| constexpr Integer | narrow_cast (T value) |
| |
| template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr> |
| constexpr T | network_to_host_endian (T value) noexcept |
| |
| template<typename Iterator > |
| constexpr Iterator | next (Iterator it, ptrdiff_t n=1) noexcept |
| | Move iterator forward n steps, if n < 0 it is only defined for types that are Bidirectional.
|
| |
| template<typename... Ts> |
| constexpr auto | none_of_f (Ts &&...needles) noexcept |
| |
| template<typename Function > |
| constexpr utility_details::NotImpl< Function > | Not (Function func) |
| |
| template<typename Function > |
| constexpr auto | not_fn () |
| |
| template<typename Function > |
| constexpr auto | not_fn (Function &&func) |
| |
| template<typename Pointer > |
| | not_null (never_null_t, not_null< Pointer >) -> not_null< Pointer > |
| |
| template<typename Pointer > |
| | not_null (never_null_t, Pointer) -> not_null< Pointer > |
| |
| template<typename Pointer > |
| | not_null (not_null< Pointer >) -> not_null< Pointer > |
| |
| template<typename Pointer > |
| | not_null (Pointer) -> not_null< Pointer > |
| |
| template<typename Bool , typename... Bools> |
| DAW_ATTRIB_INLINE constexpr bool | nsc_and (Bool lhs, Bools... rhs) noexcept |
| | Explicitly do a non-short circuiting logical and with bitwise and.
|
| |
| template<typename Bool , typename... Bools> |
| DAW_ATTRIB_INLINE constexpr bool | nsc_or (Bool lhs, Bools... rhs) noexcept |
| | Explicitly do a non-short circuiting logical or with bitwise or.
|
| |
| template<std::size_t Idx, typename... Ts> |
| constexpr auto | nth_pack_element (Ts &&...values) |
| |
template<typename A >
requires std::is_array_v<A> |
| | observer_ptr (A) -> observer_ptr< std::remove_extent_t< A > > |
| |
template<typename P >
requires std::is_pointer_v<P> |
| | observer_ptr (P) -> observer_ptr< std::remove_pointer_t< P > > |
| |
| template<typename Obj , typename T > |
| constexpr std::size_t | offset_of (T Obj::*Mem) |
| |
| template<typename Handler > |
| | on_exit_success (Handler) -> on_exit_success< Handler > |
| |
| template<typename FunctionType > |
| DAW_ATTRIB_INLINE constexpr ScopeGuard< FunctionType > | on_scope_exit (FunctionType f) noexcept(std::is_nothrow_move_constructible_v< FunctionType >) |
| |
| constexpr bool | operator! (UInt16 value) |
| |
| constexpr bool | operator! (UInt32 value) |
| |
| constexpr bool | operator! (UInt64 value) |
| |
| constexpr bool | operator! (UInt8 value) |
| |
| template<typename T , typename U , size_t N> |
| constexpr bool | operator!= (array< T, N > const &lhs, array< U, N > const &rhs) |
| |
| template<typename CharT , size_t CapacityL, size_t CapacityR> |
| constexpr bool | operator!= (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept |
| |
| template<typename Key , typename Value > |
| constexpr bool | operator!= (bounded_hash_map_iterator< Key, Value > const &lhs, bounded_hash_map_iterator< Key, Value > const &rhs) |
| |
| template<typename Key , typename Value > |
| constexpr bool | operator!= (bounded_hash_map_iterator< Key, Value > const &lhs, const_bounded_hash_map_iterator< Key, Value > const &rhs) |
| |
| template<typename Key > |
| constexpr bool | operator!= (bounded_hash_set_iterator< Key > const &lhs, bounded_hash_set_iterator< Key > const &rhs) noexcept |
| |
| template<typename Key > |
| constexpr bool | operator!= (bounded_hash_set_iterator< Key > const &lhs, const_bounded_hash_set_iterator< Key > const &rhs) noexcept |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| constexpr bool | operator!= (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename Key , typename Value > |
| constexpr bool | operator!= (const_bounded_hash_map_iterator< Key, Value > const &lhs, bounded_hash_map_iterator< Key, Value > const &rhs) |
| |
| template<typename Key , typename Value > |
| constexpr bool | operator!= (const_bounded_hash_map_iterator< Key, Value > const &lhs, const_bounded_hash_map_iterator< Key, Value > const &rhs) |
| |
| template<typename Key > |
| constexpr bool | operator!= (const_bounded_hash_set_iterator< Key > const &lhs, bounded_hash_set_iterator< Key > const &rhs) noexcept |
| |
| template<typename Key > |
| constexpr bool | operator!= (const_bounded_hash_set_iterator< Key > const &lhs, const_bounded_hash_set_iterator< Key > const &rhs) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator!= (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator!= (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| constexpr bool | operator!= (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator!= (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| bool | operator!= (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator!= (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept |
| |
| template<typename Lhs , typename Rhs > |
| DAW_ATTRIB_INLINE constexpr bool | operator!= (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept |
| |
| template<typename Pointer > |
| DAW_ATTRIB_INLINE constexpr bool | operator!= (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept |
| |
| template<typename T > |
| bool | operator!= (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator!= (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| bool | operator!= (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs) |
| |
| template<typename T , typename U > |
| bool | operator!= (heap_value< T > const &lhs, heap_value< U > const &rhs) |
| |
| template<typename T , typename U , std::enable_if_t< not std::is_convertible_v< T, U >, std::nullptr_t > = nullptr> |
| constexpr bool | operator!= (indexed_iterator< T > const &, indexed_iterator< U > const &) noexcept |
| |
| template<typename T > |
| constexpr bool | operator!= (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept |
| |
| template<typename T , typename D0 , typename D1 = D0> |
| constexpr bool | operator!= (maybe_unique_ptr< T, D0 > const &lhs, maybe_unique_ptr< T, D1 > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator!= (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept |
| |
| constexpr bool | operator!= (node_id_t const &lhs, node_id_t const &rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator!= (optional< T > const &lhs, optional< U > const &rhs) |
| |
| template<typename T > |
| constexpr bool | operator!= (optional< T > const &opt, std::nullopt_t) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator!= (optional< T > const &opt, U const &value) |
| |
| template<typename Pointer > |
| DAW_ATTRIB_INLINE constexpr bool | operator!= (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept |
| |
| template<typename T > |
| bool | operator!= (Reference< T > const &lhs, Reference< T > const &rhs) |
| |
| template<typename CharT > |
| constexpr bool | operator!= (repeat_n_char_iterator< CharT > const &lhs, repeat_n_char_iterator< CharT > const &rhs) noexcept |
| |
| template<typename Iterator1 , typename Iterator2 > |
| constexpr bool | operator!= (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs) |
| |
| template<typename Iterator > |
| constexpr bool | operator!= (splitter_range_t< Iterator > const &lhs, splitter_range_t< Iterator > const &rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator!= (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T > |
| constexpr bool | operator!= (std::nullopt_t, optional< T > const &opt) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator!= (std::nullptr_t, copiable_unique_ptr< T2, D2 > const &rhs) noexcept |
| |
| constexpr bool | operator!= (std::uint16_t lhs, UInt16 rhs) noexcept |
| |
| constexpr bool | operator!= (std::uint32_t lhs, UInt32 rhs) noexcept |
| |
| constexpr bool | operator!= (std::uint64_t lhs, UInt64 rhs) noexcept |
| |
| constexpr bool | operator!= (std::uint8_t lhs, UInt8 rhs) noexcept |
| |
| template<typename CharT > |
| constexpr bool | operator!= (string_split_iterator< CharT > const &lhs, string_split_iterator< CharT > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator!= (T const &value, optional< U > const &opt) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator!= (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| constexpr bool | operator!= (UInt16 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr bool | operator!= (UInt32 lhs, std::uint32_t rhs) noexcept |
| |
| constexpr bool | operator!= (UInt64 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator!= (UInt8 lhs, std::uint8_t rhs) noexcept |
| |
| template<typename T , typename D0 , typename D1 = D0> |
| constexpr bool | operator!= (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept |
| |
| template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_inequality< T, U >, std::nullptr_t > = nullptr> |
| constexpr bool | operator!= (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs != *rhs)) |
| |
| constexpr UInt16 | operator""_u16 (unsigned long long value) |
| |
| constexpr UInt32 | operator""_u32 (unsigned long long value) |
| |
| constexpr UInt64 | operator""_u64 (unsigned long long value) |
| |
| constexpr UInt8 | operator""_u8 (unsigned long long value) |
| |
| constexpr UInt16 | operator& (std::uint16_t lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator& (std::uint32_t lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator& (std::uint64_t lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt8 | operator& (std::uint8_t lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 | operator& (UInt16 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt16 | operator& (UInt16 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator& (UInt16 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator& (UInt16 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt16 | operator& (UInt16 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 | operator& (UInt32 lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt32 | operator& (UInt32 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator& (UInt32 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator& (UInt32 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt32 | operator& (UInt32 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 | operator& (UInt64 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt64 | operator& (UInt64 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 | operator& (UInt64 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator& (UInt64 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 | operator& (UInt64 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt8 | operator& (UInt8 lhs, std::uint8_t rhs) noexcept |
| |
| constexpr UInt32 | operator& (UInt8 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator& (UInt8 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt8 | operator& (UInt8 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 & | operator&= (UInt16 &lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt16 & | operator&= (UInt16 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt16 & | operator&= (UInt16 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 & | operator&= (UInt32 &lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt32 & | operator&= (UInt32 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 & | operator&= (UInt32 &lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt32 & | operator&= (UInt32 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 & | operator&= (UInt64 &lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt64 & | operator&= (UInt64 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 & | operator&= (UInt64 &lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 & | operator&= (UInt64 &lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 & | operator&= (UInt64 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt8 & | operator&= (UInt8 &lhs, std::uint8_t rhs) noexcept |
| |
| constexpr UInt8 & | operator&= (UInt8 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 | operator* (std::uint16_t lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator* (std::uint32_t lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator* (std::uint32_t lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt32 | operator* (std::uint32_t lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 | operator* (std::uint64_t lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt8 | operator* (std::uint8_t lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt16 | operator* (UInt16 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt16 | operator* (UInt16 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator* (UInt16 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator* (UInt16 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt16 | operator* (UInt16 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 | operator* (UInt32 lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt32 | operator* (UInt32 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator* (UInt32 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator* (UInt32 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt32 | operator* (UInt32 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 | operator* (UInt64 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt64 | operator* (UInt64 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 | operator* (UInt64 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator* (UInt64 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 | operator* (UInt64 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 | operator* (UInt8 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt8 | operator* (UInt8 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt16 | operator* (UInt8 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator* (UInt8 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator* (UInt8 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt8 | operator* (UInt8 lhs, UInt8 rhs) noexcept |
| |
| constexpr std::uint16_t & | operator*= (std::uint16_t &lhs, UInt16 rhs) noexcept |
| |
| constexpr std::uint16_t & | operator*= (std::uint16_t &lhs, UInt8 rhs) noexcept |
| |
| constexpr std::uint32_t & | operator*= (std::uint32_t &lhs, UInt16 rhs) noexcept |
| |
| constexpr std::uint32_t & | operator*= (std::uint32_t &lhs, UInt32 rhs) noexcept |
| |
| constexpr std::uint32_t & | operator*= (std::uint32_t &lhs, UInt8 rhs) noexcept |
| |
| constexpr std::uint64_t & | operator*= (std::uint64_t &lhs, UInt64 rhs) noexcept |
| |
| constexpr std::uint8_t & | operator*= (std::uint8_t &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 & | operator*= (UInt16 &lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt16 & | operator*= (UInt16 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt16 & | operator*= (UInt16 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 & | operator*= (UInt32 &lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt32 & | operator*= (UInt32 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 & | operator*= (UInt32 &lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt32 & | operator*= (UInt32 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 & | operator*= (UInt64 &lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt64 & | operator*= (UInt64 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 & | operator*= (UInt64 &lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 & | operator*= (UInt64 &lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 & | operator*= (UInt64 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt8 & | operator*= (UInt8 &lhs, std::uint8_t rhs) noexcept |
| |
| constexpr UInt8 & | operator*= (UInt8 &lhs, UInt8 rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| auto | operator+ (CharT const *lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) |
| |
| template<typename CharT , size_t N, size_t Capacity> |
| auto | operator+ (CharT(&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) |
| |
| template<typename T > |
| not_null< T > | operator+ (const not_null< T > &, std::ptrdiff_t)=delete |
| |
| template<typename CharT , size_t Capacity> |
| auto | operator+ (daw::basic_bounded_string< CharT, Capacity > lhs, CharT const *rhs) |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| auto | operator+ (daw::basic_bounded_string< CharT, Capacity > lhs, CharT(&rhs)[N]) |
| |
| template<typename CharT , size_t Capacity, typename Allocator > |
| auto | operator+ (daw::basic_bounded_string< CharT, Capacity > lhs, std::basic_string< CharT, Allocator > &&rhs) |
| |
| template<typename CharT , size_t Capacity, typename Allocator > |
| auto | operator+ (daw::basic_bounded_string< CharT, Capacity > lhs, std::basic_string< CharT, Allocator > const &rhs) |
| |
| template<typename CharT , size_t Capacity, typename Allocator > |
| auto | operator+ (std::basic_string< CharT, Allocator > lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) |
| | Appending.
|
| |
| template<typename Iterator1 , typename Tag > |
| constexpr wrap_iter< Iterator1, Tag > | operator+ (std::ptrdiff_t n, wrap_iter< Iterator1, Tag > x) noexcept |
| |
| template<typename T > |
| not_null< T > | operator+ (std::ptrdiff_t, const not_null< T > &)=delete |
| |
| constexpr UInt16 | operator+ (std::uint16_t lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator+ (std::uint32_t lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator+ (std::uint32_t lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt32 | operator+ (std::uint32_t lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 | operator+ (std::uint64_t lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt8 | operator+ (std::uint8_t lhs, UInt8 rhs) noexcept |
| |
| template<typename Iterator > |
| constexpr reverse_iterator< Iterator > | operator+ (typename reverse_iterator< Iterator >::difference_type n, reverse_iterator< Iterator > const &it) |
| |
| constexpr UInt16 | operator+ (UInt16 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt32 | operator+ (UInt16 lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt16 | operator+ (UInt16 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator+ (UInt16 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator+ (UInt16 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt16 | operator+ (UInt16 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 | operator+ (UInt16 value) |
| |
| constexpr UInt32 | operator+ (UInt32 lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt32 | operator+ (UInt32 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator+ (UInt32 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator+ (UInt32 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt32 | operator+ (UInt32 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 | operator+ (UInt32 value) |
| |
| constexpr UInt64 | operator+ (UInt64 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt64 | operator+ (UInt64 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 | operator+ (UInt64 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator+ (UInt64 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 | operator+ (UInt64 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 | operator+ (UInt64 value) |
| |
| constexpr UInt16 | operator+ (UInt8 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt32 | operator+ (UInt8 lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt8 | operator+ (UInt8 lhs, std::uint8_t rhs) noexcept |
| |
| constexpr UInt16 | operator+ (UInt8 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator+ (UInt8 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator+ (UInt8 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt8 | operator+ (UInt8 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt8 | operator+ (UInt8 value) |
| |
| constexpr UInt16 & | operator++ (UInt16 &value) |
| |
| constexpr UInt16 | operator++ (UInt16 &value, int) |
| |
| constexpr UInt32 & | operator++ (UInt32 &value) |
| |
| constexpr UInt32 | operator++ (UInt32 &value, int) |
| |
| constexpr UInt64 & | operator++ (UInt64 &value) |
| |
| constexpr UInt64 | operator++ (UInt64 &value, int) |
| |
| constexpr UInt8 & | operator++ (UInt8 &value) |
| |
| constexpr UInt8 | operator++ (UInt8 &value, int) |
| |
| constexpr std::uint16_t & | operator+= (std::uint16_t &lhs, UInt16 rhs) noexcept |
| |
| constexpr std::uint16_t & | operator+= (std::uint16_t &lhs, UInt8 rhs) noexcept |
| |
| constexpr std::uint32_t & | operator+= (std::uint32_t &lhs, UInt16 rhs) noexcept |
| |
| constexpr std::uint32_t & | operator+= (std::uint32_t &lhs, UInt32 rhs) noexcept |
| |
| constexpr std::uint32_t & | operator+= (std::uint32_t &lhs, UInt8 rhs) noexcept |
| |
| constexpr std::uint64_t & | operator+= (std::uint64_t &lhs, UInt64 rhs) noexcept |
| |
| constexpr std::uint8_t & | operator+= (std::uint8_t &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 & | operator+= (UInt16 &lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt16 & | operator+= (UInt16 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt16 & | operator+= (UInt16 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 & | operator+= (UInt32 &lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt32 & | operator+= (UInt32 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 & | operator+= (UInt32 &lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt32 & | operator+= (UInt32 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 & | operator+= (UInt64 &lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt64 & | operator+= (UInt64 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 & | operator+= (UInt64 &lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 & | operator+= (UInt64 &lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 & | operator+= (UInt64 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt8 & | operator+= (UInt8 &lhs, std::uint8_t rhs) noexcept |
| |
| constexpr UInt8 & | operator+= (UInt8 &lhs, UInt8 rhs) noexcept |
| |
| template<typename T , typename U > |
| std::ptrdiff_t | operator- (const not_null< T > &, const not_null< U > &)=delete |
| |
| template<typename T > |
| not_null< T > | operator- (const not_null< T > &, std::ptrdiff_t)=delete |
| |
| template<class Iterator1 , class Iterator2 > |
| constexpr auto | operator- (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs) -> decltype(rhs.base() - lhs.base()) |
| |
| constexpr UInt16 | operator- (std::uint16_t lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt16 | operator- (std::uint16_t lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 | operator- (std::uint32_t lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator- (std::uint32_t lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt32 | operator- (std::uint32_t lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 | operator- (std::uint64_t lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt8 | operator- (std::uint8_t lhs, UInt8 rhs) noexcept |
| |
| template<typename Iterator > |
| constexpr reverse_iterator< Iterator > | operator- (typename reverse_iterator< Iterator >::difference_type n, reverse_iterator< Iterator > const &it) |
| |
| constexpr UInt16 | operator- (UInt16 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt16 | operator- (UInt16 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator- (UInt16 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator- (UInt16 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt16 | operator- (UInt16 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 | operator- (UInt16 value) |
| |
| constexpr UInt32 | operator- (UInt32 lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt32 | operator- (UInt32 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator- (UInt32 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator- (UInt32 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt32 | operator- (UInt32 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 | operator- (UInt32 value) |
| |
| constexpr UInt64 | operator- (UInt64 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt64 | operator- (UInt64 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 | operator- (UInt64 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator- (UInt64 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 | operator- (UInt64 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 | operator- (UInt64 value) |
| |
| constexpr UInt8 | operator- (UInt8 lhs, std::uint8_t rhs) noexcept |
| |
| constexpr UInt16 | operator- (UInt8 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator- (UInt8 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator- (UInt8 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt8 | operator- (UInt8 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt8 | operator- (UInt8 value) |
| |
| template<typename Iterator1 , class Iterator2 , typename Tag > |
| constexpr auto | operator- (wrap_iter< Iterator1, Tag > const &x, wrap_iter< Iterator2, Tag > const &y) noexcept |
| |
| constexpr UInt16 & | operator-- (UInt16 &value) |
| |
| constexpr UInt16 | operator-- (UInt16 &value, int) |
| |
| constexpr UInt32 & | operator-- (UInt32 &value) |
| |
| constexpr UInt32 | operator-- (UInt32 &value, int) |
| |
| constexpr UInt64 & | operator-- (UInt64 &value) |
| |
| constexpr UInt64 | operator-- (UInt64 &value, int) |
| |
| constexpr UInt8 & | operator-- (UInt8 &value) |
| |
| constexpr UInt8 | operator-- (UInt8 &value, int) |
| |
| constexpr std::uint16_t & | operator-= (std::uint16_t &lhs, UInt16 rhs) noexcept |
| |
| constexpr std::uint16_t & | operator-= (std::uint16_t &lhs, UInt8 rhs) noexcept |
| |
| constexpr std::uint32_t & | operator-= (std::uint32_t &lhs, UInt16 rhs) noexcept |
| |
| constexpr std::uint32_t & | operator-= (std::uint32_t &lhs, UInt32 rhs) noexcept |
| |
| constexpr std::uint32_t & | operator-= (std::uint32_t &lhs, UInt8 rhs) noexcept |
| |
| constexpr std::uint64_t & | operator-= (std::uint64_t &lhs, UInt64 rhs) noexcept |
| |
| constexpr std::uint8_t & | operator-= (std::uint8_t &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 & | operator-= (UInt16 &lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt16 & | operator-= (UInt16 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt16 & | operator-= (UInt16 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 & | operator-= (UInt32 &lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt32 & | operator-= (UInt32 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 & | operator-= (UInt32 &lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt32 & | operator-= (UInt32 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 & | operator-= (UInt64 &lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt64 & | operator-= (UInt64 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 & | operator-= (UInt64 &lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 & | operator-= (UInt64 &lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 & | operator-= (UInt64 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt8 & | operator-= (UInt8 &lhs, std::uint8_t rhs) noexcept |
| |
| constexpr UInt8 & | operator-= (UInt8 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 | operator/ (std::uint16_t lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt16 | operator/ (std::uint16_t lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 | operator/ (std::uint32_t lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator/ (std::uint32_t lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt32 | operator/ (std::uint32_t lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 | operator/ (std::uint64_t lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 | operator/ (std::uint64_t lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator/ (std::uint64_t lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 | operator/ (std::uint64_t lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt8 | operator/ (std::uint8_t lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt16 | operator/ (UInt16 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt16 | operator/ (UInt16 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator/ (UInt16 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator/ (UInt16 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt16 | operator/ (UInt16 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 | operator/ (UInt32 lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt32 | operator/ (UInt32 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator/ (UInt32 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator/ (UInt32 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt32 | operator/ (UInt32 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 | operator/ (UInt64 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt64 | operator/ (UInt64 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 | operator/ (UInt64 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator/ (UInt64 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 | operator/ (UInt64 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt8 | operator/ (UInt8 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt16 | operator/ (UInt8 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator/ (UInt8 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator/ (UInt8 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt8 | operator/ (UInt8 lhs, UInt8 rhs) noexcept |
| |
| constexpr std::uint16_t & | operator/= (std::uint16_t &lhs, UInt16 rhs) noexcept |
| |
| constexpr std::uint16_t & | operator/= (std::uint16_t &lhs, UInt8 rhs) noexcept |
| |
| constexpr std::uint32_t & | operator/= (std::uint32_t &lhs, UInt32 rhs) noexcept |
| |
| constexpr std::uint64_t & | operator/= (std::uint64_t &lhs, UInt16 rhs) noexcept |
| |
| constexpr std::uint64_t & | operator/= (std::uint64_t &lhs, UInt32 rhs) noexcept |
| |
| constexpr std::uint64_t & | operator/= (std::uint64_t &lhs, UInt64 rhs) noexcept |
| |
| constexpr std::uint64_t & | operator/= (std::uint64_t &lhs, UInt8 rhs) noexcept |
| |
| constexpr std::uint8_t & | operator/= (std::uint8_t &lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt16 & | operator/= (UInt16 &lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt16 & | operator/= (UInt16 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt16 & | operator/= (UInt16 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 & | operator/= (UInt32 &lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt32 & | operator/= (UInt32 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 & | operator/= (UInt32 &lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt32 & | operator/= (UInt32 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 & | operator/= (UInt64 &lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt64 & | operator/= (UInt64 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 & | operator/= (UInt64 &lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 & | operator/= (UInt64 &lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 & | operator/= (UInt64 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt8 & | operator/= (UInt8 &lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt8 & | operator/= (UInt8 &lhs, UInt8 rhs) noexcept |
| |
| template<typename CharT , size_t CapacityL, size_t CapacityR> |
| constexpr bool | operator< (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| constexpr bool | operator< (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator< (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator< (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| constexpr bool | operator< (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator< (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| bool | operator< (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator< (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept |
| |
| template<typename Lhs , typename Rhs > |
| DAW_ATTRIB_INLINE constexpr bool | operator< (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept |
| |
| template<typename Pointer > |
| DAW_ATTRIB_INLINE constexpr bool | operator< (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept |
| |
| template<typename T > |
| bool | operator< (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator< (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| bool | operator< (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs) |
| |
| template<typename T , typename U > |
| bool | operator< (heap_value< T > const &lhs, heap_value< U > const &rhs) |
| |
| template<typename T > |
| constexpr bool | operator< (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept |
| |
| template<typename T , typename D0 , typename D1 = D0> |
| constexpr bool | operator< (maybe_unique_ptr< T, D0 > const &lhs, maybe_unique_ptr< T, D1 > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator< (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept |
| |
| constexpr bool | operator< (node_id_t const &lhs, node_id_t const &rhs) noexcept |
| |
| template<typename T > |
| constexpr bool | operator< (optional< T > const &, std::nullopt_t) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator< (optional< T > const &lhs, optional< U > const &rhs) |
| |
| template<typename T , typename U > |
| constexpr bool | operator< (optional< T > const &opt, U const &value) |
| |
| template<typename Pointer > |
| DAW_ATTRIB_INLINE constexpr bool | operator< (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept |
| |
| template<typename T > |
| bool | operator< (Reference< T > const &lhs, Reference< T > const &rhs) |
| |
| template<typename Iterator1 , typename Iterator2 > |
| constexpr bool | operator< (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator< (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T > |
| constexpr bool | operator< (std::nullopt_t, optional< T > const &opt) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator< (std::nullptr_t, copiable_unique_ptr< T1, D1 > const &rhs) noexcept |
| |
| constexpr bool | operator< (std::uint16_t lhs, UInt16 rhs) noexcept |
| |
| constexpr bool | operator< (std::uint32_t lhs, UInt32 rhs) noexcept |
| |
| constexpr bool | operator< (std::uint64_t lhs, UInt16 rhs) noexcept |
| |
| constexpr bool | operator< (std::uint64_t lhs, UInt32 rhs) noexcept |
| |
| constexpr bool | operator< (std::uint64_t lhs, UInt64 rhs) noexcept |
| |
| constexpr bool | operator< (std::uint64_t lhs, UInt8 rhs) noexcept |
| |
| constexpr bool | operator< (std::uint8_t lhs, UInt8 rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator< (T const &value, optional< U > const &opt) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator< (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| constexpr bool | operator< (UInt16 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr bool | operator< (UInt32 lhs, std::uint32_t rhs) noexcept |
| |
| constexpr bool | operator< (UInt64 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator< (UInt8 lhs, std::uint8_t rhs) noexcept |
| |
| template<typename T , typename D0 , typename D1 = D0> |
| constexpr bool | operator< (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept |
| |
| template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_less< T, U >, std::nullptr_t > = nullptr> |
| constexpr bool | operator< (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs< *rhs)) |
| |
| template<typename OStream , typename CharT , size_t Capacity, std::enable_if_t< daw::traits::is_ostream_like_v< OStream, CharT >, std::nullptr_t > = nullptr> |
| OStream & | operator<< (OStream &os, daw::basic_bounded_string< CharT, Capacity > const &str) |
| |
| template<typename OStream , typename T , std::enable_if_t< daw::traits::is_ostream_like_lite_v< OStream >, std::nullptr_t > = nullptr> |
| OStream & | operator<< (OStream &os, Reference< T > const &ref) |
| |
| template<size_t BitWidth> |
| std::ostream & | operator<< (std::ostream &os, static_bitset< BitWidth > const &bs) |
| |
| std::ostream & | operator<< (std::ostream &os, UInt16 rhs) |
| |
| std::ostream & | operator<< (std::ostream &os, UInt32 rhs) |
| |
| std::ostream & | operator<< (std::ostream &os, UInt64 rhs) |
| |
| std::ostream & | operator<< (std::ostream &os, UInt8 rhs) |
| |
| constexpr std::uint16_t | operator<< (std::uint16_t b, UInt16 shift) noexcept |
| |
| constexpr std::uint32_t | operator<< (std::uint32_t b, UInt32 shift) noexcept |
| |
| constexpr std::uint64_t | operator<< (std::uint64_t b, UInt16 shift) noexcept |
| |
| constexpr std::uint64_t | operator<< (std::uint64_t b, UInt32 shift) noexcept |
| |
| constexpr std::uint64_t | operator<< (std::uint64_t b, UInt64 shift) noexcept |
| |
| constexpr std::uint64_t | operator<< (std::uint64_t b, UInt8 shift) noexcept |
| |
| constexpr std::uint8_t | operator<< (std::uint8_t b, UInt8 shift) noexcept |
| |
| constexpr UInt16 | operator<< (UInt16 b, std::uint16_t shift) noexcept |
| |
| constexpr UInt16 | operator<< (UInt16 b, UInt16 shift) noexcept |
| |
| constexpr UInt16 | operator<< (UInt16 b, UInt8 shift) noexcept |
| |
| constexpr UInt32 | operator<< (UInt32 b, std::uint32_t shift) noexcept |
| |
| constexpr UInt32 | operator<< (UInt32 b, UInt16 shift) noexcept |
| |
| constexpr UInt32 | operator<< (UInt32 b, UInt32 shift) noexcept |
| |
| constexpr UInt32 | operator<< (UInt32 b, UInt8 shift) noexcept |
| |
| constexpr UInt64 | operator<< (UInt64 b, std::uint64_t shift) noexcept |
| |
| constexpr UInt64 | operator<< (UInt64 b, UInt16 shift) noexcept |
| |
| constexpr UInt64 | operator<< (UInt64 b, UInt32 shift) noexcept |
| |
| constexpr UInt64 | operator<< (UInt64 b, UInt64 shift) noexcept |
| |
| constexpr UInt64 | operator<< (UInt64 b, UInt8 shift) noexcept |
| |
| constexpr UInt8 | operator<< (UInt8 b, std::uint8_t shift) noexcept |
| |
| constexpr UInt8 | operator<< (UInt8 b, UInt8 shift) noexcept |
| |
| constexpr UInt16 & | operator<<= (UInt16 &b, std::uint16_t shift) noexcept |
| |
| constexpr UInt16 & | operator<<= (UInt16 &b, UInt16 shift) noexcept |
| |
| constexpr UInt16 & | operator<<= (UInt16 &b, UInt8 shift) noexcept |
| |
| constexpr UInt32 & | operator<<= (UInt32 &b, std::uint32_t shift) noexcept |
| |
| constexpr UInt32 & | operator<<= (UInt32 &b, UInt16 shift) noexcept |
| |
| constexpr UInt32 & | operator<<= (UInt32 &b, UInt32 shift) noexcept |
| |
| constexpr UInt32 & | operator<<= (UInt32 &b, UInt8 shift) noexcept |
| |
| constexpr UInt64 & | operator<<= (UInt64 &b, std::uint64_t shift) noexcept |
| |
| constexpr UInt64 & | operator<<= (UInt64 &b, UInt16 shift) noexcept |
| |
| constexpr UInt64 & | operator<<= (UInt64 &b, UInt32 shift) noexcept |
| |
| constexpr UInt64 & | operator<<= (UInt64 &b, UInt64 shift) noexcept |
| |
| constexpr UInt64 & | operator<<= (UInt64 &b, UInt8 shift) noexcept |
| |
| constexpr UInt8 & | operator<<= (UInt8 &b, std::uint8_t shift) noexcept |
| |
| constexpr UInt8 & | operator<<= (UInt8 &b, UInt8 shift) noexcept |
| |
| template<typename CharT , size_t CapacityL, size_t CapacityR> |
| constexpr bool | operator<= (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| constexpr bool | operator<= (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator<= (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator<= (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| constexpr bool | operator<= (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator<= (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| bool | operator<= (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator<= (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept |
| |
| template<typename Lhs , typename Rhs > |
| DAW_ATTRIB_INLINE constexpr bool | operator<= (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept |
| |
| template<typename Pointer > |
| DAW_ATTRIB_INLINE constexpr bool | operator<= (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept |
| |
| template<typename T > |
| bool | operator<= (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator<= (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| bool | operator<= (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs) |
| |
| template<typename T , typename U > |
| bool | operator<= (heap_value< T > const &lhs, heap_value< U > const &rhs) |
| |
| template<typename T > |
| constexpr bool | operator<= (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept |
| |
| template<typename T , typename D0 , typename D1 = D0> |
| constexpr bool | operator<= (maybe_unique_ptr< T, D0 > const &lhs, maybe_unique_ptr< T, D1 > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator<= (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator<= (optional< T > const &lhs, optional< U > const &rhs) |
| |
| template<typename T > |
| constexpr bool | operator<= (optional< T > const &opt, std::nullopt_t) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator<= (optional< T > const &opt, U const &value) |
| |
| template<typename Pointer > |
| DAW_ATTRIB_INLINE constexpr bool | operator<= (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept |
| |
| template<typename T > |
| bool | operator<= (Reference< T > const &lhs, Reference< T > const &rhs) |
| |
| template<typename Iterator1 , typename Iterator2 > |
| constexpr bool | operator<= (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator<= (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T > |
| constexpr bool | operator<= (std::nullopt_t, optional< T > const &) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator<= (std::nullptr_t, copiable_unique_ptr< T2, D2 > const &rhs) noexcept |
| |
| constexpr bool | operator<= (std::uint16_t lhs, UInt16 rhs) noexcept |
| |
| constexpr bool | operator<= (std::uint32_t lhs, UInt32 rhs) noexcept |
| |
| constexpr bool | operator<= (std::uint64_t lhs, UInt16 rhs) noexcept |
| |
| constexpr bool | operator<= (std::uint64_t lhs, UInt32 rhs) noexcept |
| |
| constexpr bool | operator<= (std::uint64_t lhs, UInt64 rhs) noexcept |
| |
| constexpr bool | operator<= (std::uint64_t lhs, UInt8 rhs) noexcept |
| |
| constexpr bool | operator<= (std::uint8_t lhs, UInt8 rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator<= (T const &value, optional< U > const &opt) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator<= (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| constexpr bool | operator<= (UInt16 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr bool | operator<= (UInt16 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator<= (UInt32 lhs, std::uint32_t rhs) noexcept |
| |
| constexpr bool | operator<= (UInt32 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator<= (UInt64 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator<= (UInt8 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator<= (UInt8 lhs, std::uint8_t rhs) noexcept |
| |
| template<typename T , typename D0 , typename D1 = D0> |
| constexpr bool | operator<= (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept |
| |
| template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_less_equal< T, U >, std::nullptr_t > = nullptr> |
| constexpr bool | operator<= (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs<= *rhs)) |
| |
| template<typename T , typename U , size_t N> |
| constexpr bool | operator== (array< T, N > const &lhs, array< U, N > const &rhs) |
| |
| template<typename CharT , size_t CapacityL, size_t CapacityR> |
| constexpr bool | operator== (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept |
| |
| template<typename Key , typename Value > |
| constexpr bool | operator== (bounded_hash_map_iterator< Key, Value > const &lhs, bounded_hash_map_iterator< Key, Value > const &rhs) |
| |
| template<typename Key , typename Value > |
| constexpr bool | operator== (bounded_hash_map_iterator< Key, Value > const &lhs, const_bounded_hash_map_iterator< Key, Value > const &rhs) |
| |
| template<typename Key > |
| constexpr bool | operator== (bounded_hash_set_iterator< Key > const &lhs, bounded_hash_set_iterator< Key > const &rhs) noexcept |
| |
| template<typename Key > |
| constexpr bool | operator== (bounded_hash_set_iterator< Key > const &lhs, const_bounded_hash_set_iterator< Key > const &rhs) noexcept |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| constexpr bool | operator== (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename Key , typename Value > |
| constexpr bool | operator== (const_bounded_hash_map_iterator< Key, Value > const &lhs, bounded_hash_map_iterator< Key, Value > const &rhs) |
| |
| template<typename Key , typename Value > |
| constexpr bool | operator== (const_bounded_hash_map_iterator< Key, Value > const &lhs, const_bounded_hash_map_iterator< Key, Value > const &rhs) |
| |
| template<typename Key > |
| constexpr bool | operator== (const_bounded_hash_set_iterator< Key > const &lhs, bounded_hash_set_iterator< Key > const &rhs) noexcept |
| |
| template<typename Key > |
| constexpr bool | operator== (const_bounded_hash_set_iterator< Key > const &lhs, const_bounded_hash_set_iterator< Key > const &rhs) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator== (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator== (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| constexpr bool | operator== (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator== (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| bool | operator== (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator== (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept |
| |
| template<typename Lhs , typename Rhs > |
| DAW_ATTRIB_INLINE constexpr bool | operator== (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept |
| |
| template<typename Pointer > |
| DAW_ATTRIB_INLINE constexpr bool | operator== (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept |
| |
| template<typename T > |
| bool | operator== (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator== (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| bool | operator== (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs) |
| |
| template<typename T , typename U > |
| bool | operator== (heap_value< T > const &lhs, heap_value< U > const &rhs) |
| |
| template<typename T , typename U , std::enable_if_t< not std::is_convertible_v< T, U >, std::nullptr_t > = nullptr> |
| constexpr bool | operator== (indexed_iterator< T > const &, indexed_iterator< U > const &) noexcept |
| |
| template<typename T > |
| constexpr bool | operator== (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept |
| |
| template<typename T , typename D0 , typename D1 = D0> |
| constexpr bool | operator== (maybe_unique_ptr< T, D0 > const &lhs, maybe_unique_ptr< T, D1 > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator== (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept |
| |
| constexpr bool | operator== (node_id_t const &lhs, node_id_t const &rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator== (optional< T > const &lhs, optional< U > const &rhs) |
| |
| template<typename T > |
| constexpr bool | operator== (optional< T > const &opt, std::nullopt_t) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator== (optional< T > const &opt, U const &value) |
| |
| template<typename Pointer > |
| DAW_ATTRIB_INLINE constexpr bool | operator== (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept |
| |
| template<typename T > |
| bool | operator== (Reference< T > const &lhs, Reference< T > const &rhs) |
| |
| template<typename CharT > |
| constexpr bool | operator== (repeat_n_char_iterator< CharT > const &lhs, repeat_n_char_iterator< CharT > const &rhs) noexcept |
| |
| template<typename Iterator1 , typename Iterator2 > |
| constexpr bool | operator== (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs) |
| |
| template<typename Iterator > |
| constexpr bool | operator== (splitter_range_t< Iterator > const &lhs, splitter_range_t< Iterator > const &rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator== (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T > |
| constexpr bool | operator== (std::nullopt_t, optional< T > const &opt) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator== (std::nullptr_t, copiable_unique_ptr< T1, D1 > const &rhs) noexcept |
| |
| constexpr bool | operator== (std::uint16_t lhs, UInt16 rhs) noexcept |
| |
| constexpr bool | operator== (std::uint32_t lhs, UInt32 rhs) noexcept |
| |
| constexpr bool | operator== (std::uint64_t lhs, UInt16 rhs) noexcept |
| |
| constexpr bool | operator== (std::uint64_t lhs, UInt32 rhs) noexcept |
| |
| constexpr bool | operator== (std::uint64_t lhs, UInt64 rhs) noexcept |
| |
| constexpr bool | operator== (std::uint64_t lhs, UInt8 rhs) noexcept |
| |
| constexpr bool | operator== (std::uint8_t lhs, UInt8 rhs) noexcept |
| |
| template<typename CharT > |
| constexpr bool | operator== (string_split_iterator< CharT > const &lhs, string_split_iterator< CharT > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator== (T const &value, optional< U > const &opt) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator== (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| constexpr bool | operator== (UInt16 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr bool | operator== (UInt32 lhs, std::uint32_t rhs) noexcept |
| |
| constexpr bool | operator== (UInt64 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator== (UInt64 lhs, UInt16 rhs) noexcept |
| |
| constexpr bool | operator== (UInt64 lhs, UInt32 rhs) noexcept |
| |
| constexpr bool | operator== (UInt64 lhs, UInt8 rhs) noexcept |
| |
| constexpr bool | operator== (UInt8 lhs, std::uint8_t rhs) noexcept |
| |
| template<typename T , typename D0 , typename D1 = D0> |
| constexpr bool | operator== (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept |
| |
| template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_equality< T, U >, std::nullptr_t > = nullptr> |
| constexpr bool | operator== (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs== *rhs)) |
| |
| template<typename CharT , size_t CapacityL, size_t CapacityR> |
| constexpr bool | operator> (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| constexpr bool | operator> (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator> (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator> (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| constexpr bool | operator> (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator> (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| bool | operator> (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator> (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept |
| |
| template<typename Lhs , typename Rhs > |
| DAW_ATTRIB_INLINE constexpr bool | operator> (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept |
| |
| template<typename Pointer > |
| DAW_ATTRIB_INLINE constexpr bool | operator> (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept |
| |
| template<typename T > |
| bool | operator> (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator> (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| bool | operator> (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs) |
| |
| template<typename T , typename U > |
| bool | operator> (heap_value< T > const &lhs, heap_value< U > const &rhs) |
| |
| template<typename T > |
| constexpr bool | operator> (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept |
| |
| template<typename T , typename D0 , typename D1 = D0> |
| constexpr bool | operator> (maybe_unique_ptr< T, D0 > const &lhs, maybe_unique_ptr< T, D1 > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator> (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator> (optional< T > const &lhs, optional< U > const &rhs) |
| |
| template<typename T > |
| constexpr bool | operator> (optional< T > const &opt, std::nullopt_t) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator> (optional< T > const &opt, U const &value) |
| |
| template<typename Pointer > |
| DAW_ATTRIB_INLINE constexpr bool | operator> (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept |
| |
| template<typename T > |
| bool | operator> (Reference< T > const &lhs, Reference< T > const &rhs) |
| |
| template<typename Iterator1 , typename Iterator2 > |
| constexpr bool | operator> (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator> (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T > |
| constexpr bool | operator> (std::nullopt_t, optional< T > const &) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator> (std::nullptr_t, copiable_unique_ptr< T2, D2 > const &rhs) noexcept |
| |
| constexpr bool | operator> (std::uint16_t lhs, UInt16 rhs) noexcept |
| |
| constexpr bool | operator> (std::uint64_t lhs, UInt16 rhs) noexcept |
| |
| constexpr bool | operator> (std::uint64_t lhs, UInt32 rhs) noexcept |
| |
| constexpr bool | operator> (std::uint64_t lhs, UInt64 rhs) noexcept |
| |
| constexpr bool | operator> (std::uint64_t lhs, UInt8 rhs) noexcept |
| |
| constexpr bool | operator> (std::uint8_t lhs, UInt8 rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator> (T const &value, optional< U > const &opt) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator> (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| constexpr bool | operator> (UInt16 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr bool | operator> (UInt16 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator> (UInt32 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator> (UInt64 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator> (UInt8 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator> (UInt8 lhs, std::uint8_t rhs) noexcept |
| |
| template<typename T , typename D0 , typename D1 = D0> |
| constexpr bool | operator> (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept |
| |
| template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_greater< T, U >, std::nullptr_t > = nullptr> |
| constexpr bool | operator> (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs > *rhs)) |
| |
| template<typename CharT , size_t CapacityL, size_t CapacityR> |
| constexpr bool | operator>= (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| constexpr bool | operator>= (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator>= (const T &value, const optional< U > &opt) |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator>= (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator>= (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| constexpr bool | operator>= (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator>= (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| bool | operator>= (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator>= (daw::basic_bounded_string< CharT, Capacity > lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept |
| |
| template<typename Lhs , typename Rhs > |
| DAW_ATTRIB_INLINE constexpr bool | operator>= (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept |
| |
| template<typename Pointer > |
| DAW_ATTRIB_INLINE constexpr bool | operator>= (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept |
| |
| template<typename T > |
| bool | operator>= (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator>= (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| bool | operator>= (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs) |
| |
| template<typename T , typename U > |
| bool | operator>= (heap_value< T > const &lhs, heap_value< U > const &rhs) |
| |
| template<typename T > |
| constexpr bool | operator>= (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept |
| |
| template<typename T , typename D0 , typename D1 = D0> |
| constexpr bool | operator>= (maybe_unique_ptr< T, D0 > const &lhs, maybe_unique_ptr< T, D1 > const &rhs) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator>= (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept |
| |
| template<typename T > |
| constexpr bool | operator>= (optional< T > const &, std::nullopt_t) noexcept |
| |
| template<typename T , typename U > |
| constexpr bool | operator>= (optional< T > const &lhs, optional< U > const &rhs) |
| |
| template<typename T , typename U > |
| constexpr bool | operator>= (optional< T > const &opt, U const &value) |
| |
| template<typename Pointer > |
| DAW_ATTRIB_INLINE constexpr bool | operator>= (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept |
| |
| template<typename T > |
| bool | operator>= (Reference< T > const &lhs, Reference< T > const &rhs) |
| |
| template<typename Iterator1 , typename Iterator2 > |
| constexpr bool | operator>= (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs) |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator>= (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| template<typename T > |
| constexpr bool | operator>= (std::nullopt_t, optional< T > const &opt) noexcept |
| |
| template<typename T1 , typename D1 , typename T2 , typename D2 > |
| constexpr bool | operator>= (std::nullptr_t, copiable_unique_ptr< T2, D2 > const &rhs) noexcept |
| |
| constexpr bool | operator>= (std::uint16_t lhs, UInt16 rhs) noexcept |
| |
| constexpr bool | operator>= (std::uint32_t lhs, UInt32 rhs) noexcept |
| |
| constexpr bool | operator>= (std::uint64_t lhs, UInt16 rhs) noexcept |
| |
| constexpr bool | operator>= (std::uint64_t lhs, UInt32 rhs) noexcept |
| |
| constexpr bool | operator>= (std::uint64_t lhs, UInt64 rhs) noexcept |
| |
| constexpr bool | operator>= (std::uint64_t lhs, UInt8 rhs) noexcept |
| |
| constexpr bool | operator>= (std::uint8_t lhs, UInt8 rhs) noexcept |
| |
| template<typename CharT , size_t Capacity> |
| constexpr bool | operator>= (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept |
| |
| constexpr bool | operator>= (UInt16 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr bool | operator>= (UInt16 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator>= (UInt32 lhs, std::uint32_t rhs) noexcept |
| |
| constexpr bool | operator>= (UInt32 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator>= (UInt64 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator>= (UInt8 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr bool | operator>= (UInt8 lhs, std::uint8_t rhs) noexcept |
| |
| template<typename T , typename D0 , typename D1 = D0> |
| constexpr bool | operator>= (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept |
| |
| template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_greater_equal< T, U >, std::nullptr_t > = nullptr> |
| constexpr bool | operator>= (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs >= *rhs)) |
| |
| constexpr std::uint16_t | operator>> (std::uint16_t b, UInt16 shift) noexcept |
| |
| constexpr std::uint32_t | operator>> (std::uint32_t b, UInt16 shift) noexcept |
| |
| constexpr std::uint32_t | operator>> (std::uint32_t b, UInt32 shift) noexcept |
| |
| constexpr std::uint32_t | operator>> (std::uint32_t b, UInt8 shift) noexcept |
| |
| constexpr std::uint64_t | operator>> (std::uint64_t b, UInt16 shift) noexcept |
| |
| constexpr std::uint64_t | operator>> (std::uint64_t b, UInt32 shift) noexcept |
| |
| constexpr std::uint64_t | operator>> (std::uint64_t b, UInt64 shift) noexcept |
| |
| constexpr std::uint64_t | operator>> (std::uint64_t b, UInt8 shift) noexcept |
| |
| constexpr std::uint8_t | operator>> (std::uint8_t b, UInt8 shift) noexcept |
| |
| constexpr UInt16 | operator>> (UInt16 b, std::uint16_t shift) noexcept |
| |
| constexpr UInt16 | operator>> (UInt16 b, UInt16 shift) noexcept |
| |
| constexpr UInt32 | operator>> (UInt32 b, std::uint32_t shift) noexcept |
| |
| constexpr UInt32 | operator>> (UInt32 b, UInt16 shift) noexcept |
| |
| constexpr UInt32 | operator>> (UInt32 b, UInt32 shift) noexcept |
| |
| constexpr UInt32 | operator>> (UInt32 b, UInt8 shift) noexcept |
| |
| constexpr UInt64 | operator>> (UInt64 b, std::uint64_t shift) noexcept |
| |
| constexpr UInt64 | operator>> (UInt64 b, UInt16 shift) noexcept |
| |
| constexpr UInt64 | operator>> (UInt64 b, UInt32 shift) noexcept |
| |
| constexpr UInt64 | operator>> (UInt64 b, UInt64 shift) noexcept |
| |
| constexpr UInt64 | operator>> (UInt64 b, UInt8 shift) noexcept |
| |
| constexpr UInt8 | operator>> (UInt8 b, std::uint8_t shift) noexcept |
| |
| constexpr UInt8 | operator>> (UInt8 b, UInt8 shift) noexcept |
| |
| constexpr UInt16 & | operator>>= (UInt16 &b, std::uint16_t shift) noexcept |
| |
| constexpr UInt16 & | operator>>= (UInt16 &b, UInt16 shift) noexcept |
| |
| constexpr UInt16 & | operator>>= (UInt16 &b, UInt8 shift) noexcept |
| |
| constexpr UInt32 & | operator>>= (UInt32 &b, std::uint32_t shift) noexcept |
| |
| constexpr UInt32 & | operator>>= (UInt32 &b, UInt16 shift) noexcept |
| |
| constexpr UInt32 & | operator>>= (UInt32 &b, UInt32 shift) noexcept |
| |
| constexpr UInt32 & | operator>>= (UInt32 &b, UInt8 shift) noexcept |
| |
| constexpr UInt64 & | operator>>= (UInt64 &b, std::uint64_t shift) noexcept |
| |
| constexpr UInt64 & | operator>>= (UInt64 &b, UInt16 shift) noexcept |
| |
| constexpr UInt64 & | operator>>= (UInt64 &b, UInt32 shift) noexcept |
| |
| constexpr UInt64 & | operator>>= (UInt64 &b, UInt64 shift) noexcept |
| |
| constexpr UInt64 & | operator>>= (UInt64 &b, UInt8 shift) noexcept |
| |
| constexpr UInt8 & | operator>>= (UInt8 &b, std::uint8_t shift) noexcept |
| |
| constexpr UInt8 & | operator>>= (UInt8 &b, UInt8 shift) noexcept |
| |
| constexpr UInt16 | operator^ (std::uint16_t lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator^ (std::uint32_t lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator^ (std::uint64_t lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt8 | operator^ (std::uint8_t lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 | operator^ (UInt16 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt16 | operator^ (UInt16 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator^ (UInt16 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator^ (UInt16 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt16 | operator^ (UInt16 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 | operator^ (UInt32 lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt32 | operator^ (UInt32 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator^ (UInt32 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator^ (UInt32 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt32 | operator^ (UInt32 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 | operator^ (UInt64 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt64 | operator^ (UInt64 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 | operator^ (UInt64 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator^ (UInt64 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 | operator^ (UInt64 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt8 | operator^ (UInt8 lhs, std::uint8_t rhs) noexcept |
| |
| constexpr UInt32 | operator^ (UInt8 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator^ (UInt8 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt8 | operator^ (UInt8 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 & | operator^= (UInt16 &lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt16 & | operator^= (UInt16 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt16 & | operator^= (UInt16 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 & | operator^= (UInt32 &lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt32 & | operator^= (UInt32 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 & | operator^= (UInt32 &lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt32 & | operator^= (UInt32 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 & | operator^= (UInt64 &lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt64 & | operator^= (UInt64 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 & | operator^= (UInt64 &lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 & | operator^= (UInt64 &lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 & | operator^= (UInt64 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt8 & | operator^= (UInt8 &lhs, std::uint8_t rhs) noexcept |
| |
| constexpr UInt8 & | operator^= (UInt8 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 | operator| (std::uint16_t lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator| (std::uint32_t lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator| (std::uint64_t lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt8 | operator| (std::uint8_t lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 | operator| (UInt16 lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt16 | operator| (UInt16 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator| (UInt16 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator| (UInt16 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt16 | operator| (UInt16 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 | operator| (UInt32 lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt32 | operator| (UInt32 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 | operator| (UInt32 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator| (UInt32 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt32 | operator| (UInt32 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 | operator| (UInt64 lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt64 | operator| (UInt64 lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 | operator| (UInt64 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator| (UInt64 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 | operator| (UInt64 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt8 | operator| (UInt8 lhs, std::uint8_t rhs) noexcept |
| |
| constexpr UInt32 | operator| (UInt8 lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 | operator| (UInt8 lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt8 | operator| (UInt8 lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 & | operator|= (UInt16 &lhs, std::uint16_t rhs) noexcept |
| |
| constexpr UInt16 & | operator|= (UInt16 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt16 & | operator|= (UInt16 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt32 & | operator|= (UInt32 &lhs, std::uint32_t rhs) noexcept |
| |
| constexpr UInt32 & | operator|= (UInt32 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt32 & | operator|= (UInt32 &lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt32 & | operator|= (UInt32 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt64 & | operator|= (UInt64 &lhs, std::uint64_t rhs) noexcept |
| |
| constexpr UInt64 & | operator|= (UInt64 &lhs, UInt16 rhs) noexcept |
| |
| constexpr UInt64 & | operator|= (UInt64 &lhs, UInt32 rhs) noexcept |
| |
| constexpr UInt64 & | operator|= (UInt64 &lhs, UInt64 rhs) noexcept |
| |
| constexpr UInt64 & | operator|= (UInt64 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt8 & | operator|= (UInt8 &lhs, std::uint8_t rhs) noexcept |
| |
| constexpr UInt8 & | operator|= (UInt8 &lhs, UInt8 rhs) noexcept |
| |
| constexpr UInt16 | operator~ (UInt16 value) |
| |
| constexpr UInt32 | operator~ (UInt32 value) |
| |
| constexpr UInt64 | operator~ (UInt64 value) |
| |
| constexpr UInt8 | operator~ (UInt8 value) |
| |
| constexpr auto | or_all () noexcept |
| |
| template<typename Value > |
| constexpr Value | or_all (Value value) noexcept |
| |
| template<typename Value , typename... T> |
| constexpr decltype(auto) | or_all (Value value, T... values) noexcept |
| |
| template<typename... Funcs> |
| | overload (Funcs &&...) -> overload< conditional_t< std::is_class_v< daw::remove_cvref_t< Funcs > >, daw::remove_cvref_t< Funcs >, Funcs >... > |
| |
| template<typename Function , typename... Args> |
| constexpr void | pack_apply (std::size_t N, Function &&func, Args &&...args) |
| |
| template<size_t N, std::size_t pos = 0, typename Arg , typename... Args> |
| constexpr decltype(auto) | pack_get (Arg &&arg, Args &&...args) noexcept |
| |
| template<typename T , typename BitStream > |
| auto | pop_value (BitStream &bs) |
| |
| template<typename T , typename BitStream > |
| auto | pop_value (BitStream &bs, size_t bits_needed) |
| |
| template<typename Iterator > |
| constexpr Iterator | prev (Iterator it, ptrdiff_t n=1) noexcept |
| | Move iterator backward n steps, if n > 0, only defined for types that are Bidirectional.
|
| |
| template<typename... Args> |
| DAW_ATTRIB_NOINLINE void | print (FILE *fout, std::format_string< Args... > fmt, Args &&...args) |
| |
| template<typename... Args> |
| DAW_ATTRIB_NOINLINE void | print (std::format_string< Args... > fmt, Args &&...args) |
| |
| template<typename... Args> |
| std::ostream & | print (std::ostream &os, std::format_string< Args... > fmt, Args &&...args) |
| |
| template<typename... Args> |
| std::ostream & | print_log (std::format_string< Args... > fmt, Args &&...args) |
| |
| DAW_ATTRIB_INLINE void | println () |
| |
| template<typename... Args> |
| DAW_ATTRIB_NOINLINE void | println (FILE *f, std::format_string< Args... > fmt, Args &&...args) |
| |
| template<typename... Args> |
| DAW_ATTRIB_NOINLINE void | println (std::format_string< Args... > fmt, Args &&...args) |
| |
| template<typename... Args> |
| std::ostream & | println (std::ostream &os, std::format_string< Args... > fmt, Args &&...args) |
| |
| template<typename RandomIterator , typename Compare = std::less<>> |
| constexpr void | quick_sort (RandomIterator f, RandomIterator l, Compare cmp=Compare{ }) |
| |
| template<typename IntType > |
| IntType | randint () |
| |
| template<typename IntType > |
| IntType | randint (IntType a, IntType b) |
| |
| template<typename IntType , typename ItValueType = IntType, typename ForwardIterator > |
| void | random_fill (ForwardIterator first, ForwardIterator const last, IntType a, IntType b) |
| |
| template<typename CharT = char> |
| DAW_ATTRIB_NOINLINE std::optional< std::basic_string< CharT > > | read_file (std::string const &path) |
| |
| std::string | read_file (std::string const &path, terminate_on_read_file_error_t) |
| |
| template<typename T , typename = void> |
| auto | ref (T const &value) |
| |
| template<typename T > |
| auto | ref (T const *value) |
| |
| template<typename T = char> |
| constexpr auto | repeat_n_char_end () noexcept |
| |
| template<typename CharT > |
| | repeat_n_char_iterator (size_t, CharT) -> repeat_n_char_iterator< CharT > |
| |
| void | reseed () |
| |
| void | reseed (std::default_random_engine::result_type value) |
| |
| template<typename T > |
| void | return_buffer (T *ptr) noexcept |
| |
| template<typename Iterator > |
| | reverse_iterator (Iterator) -> reverse_iterator< Iterator > |
| |
| template<typename T , typename Func , typename Compare = daw::graph_alg_impl::NoSort> |
| void | reverse_topological_sorted_walk (daw::graph_t< T > &known_deps, Func visitor, Compare &&comp=Compare{ }) |
| |
| template<typename T , typename Func , typename Compare = daw::graph_alg_impl::NoSort> |
| void | reverse_topological_sorted_walk (daw::graph_t< T > const &known_deps, Func visitor, Compare &&comp=Compare{ }) |
| |
| template<typename T > |
| | ring_adaptor (T const &) -> ring_adaptor< T > |
| |
| template<unsigned bits> |
| constexpr UInt16 | rotate_left (UInt16 value) |
| |
| constexpr UInt16 | rotate_left (UInt16 value, unsigned bits) |
| |
| template<unsigned bits> |
| constexpr UInt32 | rotate_left (UInt32 value) |
| |
| constexpr UInt32 | rotate_left (UInt32 value, unsigned bits) |
| |
| template<unsigned bits> |
| constexpr UInt64 | rotate_left (UInt64 value) |
| |
| constexpr UInt64 | rotate_left (UInt64 value, unsigned bits) |
| |
| template<unsigned bits> |
| constexpr UInt8 | rotate_left (UInt8 value) |
| |
| constexpr UInt8 | rotate_left (UInt8 value, unsigned bits) |
| |
| template<unsigned bits> |
| constexpr UInt16 | rotate_right (UInt16 value) |
| |
| constexpr UInt16 | rotate_right (UInt16 value, unsigned bits) |
| |
| template<unsigned bits> |
| constexpr UInt32 | rotate_right (UInt32 value) |
| |
| constexpr UInt32 | rotate_right (UInt32 value, unsigned bits) |
| |
| template<unsigned bits> |
| constexpr UInt64 | rotate_right (UInt64 value) |
| |
| constexpr UInt64 | rotate_right (UInt64 value, unsigned bits) |
| |
| template<unsigned bits> |
| constexpr UInt8 | rotate_right (UInt8 value) |
| |
| constexpr UInt8 | rotate_right (UInt8 value, unsigned bits) |
| |
| template<typename T > |
| auto | RunIfValid (std::weak_ptr< T > w_ptr) |
| |
| template<typename T > |
| | rw_ref (T &) -> rw_ref< T > |
| |
| template<typename Container , typename Iterator , typename Distance > |
| constexpr void | safe_advance (Container &container, Iterator &it, Distance distance) noexcept |
| | Advance Iterator within the bounds of container.
|
| |
| template<typename Container , typename Iterator , typename Distance > |
| constexpr void | safe_advance (Container const &container, Iterator &it, Distance distance) noexcept |
| | Advance Iterator within the bounds of container.
|
| |
| template<typename Iterator , typename Distance = size_t> |
| constexpr Iterator | safe_next (Iterator it, Iterator const last, Distance n=1U) noexcept(noexcept(daw::next(it, static_cast< std::ptrdiff_t >(n)))) |
| | Advance iterator n steps forward but do not go past last. Undefined if it > last.
|
| |
| template<typename Iterator , typename Distance > |
| constexpr Iterator | safe_prev (Iterator it, Iterator first, Distance n=1) noexcept(noexcept(daw::prev(it, static_cast< std::ptrdiff_t >(n)))) |
| | Advance iterator n steps backward but do not go past first. Undefined if it < first.
|
| |
| template<unsigned N> |
| constexpr void | set_bit (UInt16 &value, bool state) |
| |
| template<unsigned N> |
| constexpr void | set_bit (UInt32 &value, bool state) |
| |
| template<unsigned N> |
| constexpr void | set_bit (UInt64 &value, bool state) |
| |
| template<unsigned N> |
| constexpr void | set_bit (UInt8 &value, bool state) |
| |
| template<typename Integer , typename Bit , typename... Bits> |
| constexpr Integer | set_bits (Integer i, Bit b, Bits... bs) noexcept |
| | set bits at positions specified by b,bs...
|
| |
| template<typename Func > |
| DAW_ATTRIB_NOINLINE void | show_benchmark (size_t data_size_bytes, std::string const &title, Func &&func, size_t data_prec=1, size_t time_prec=0, size_t item_count=1) |
| |
| template<typename RandomIterator > |
| void | shuffle (RandomIterator first, RandomIterator last) |
| |
| template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr> |
| DAW_ATTRIB_INLINE constexpr bool | signbit (T t) |
| |
| template<typename T , typename... Ts> |
| | simple_array (T &&, Ts &&...) -> simple_array< T, sizeof...(Ts)+1 > |
| |
| template<typename Byte > |
| constexpr uint64_t | siphash24 (Byte const *first, size_t sz, Byte const *const key) |
| |
| template<typename Container > |
| constexpr auto | size (Container const &c) noexcept(noexcept(c.size())) -> decltype(c.size()) |
| |
| template<typename BitStream > |
| void | skip_bits (BitStream &bs, size_t bits_needed) |
| |
| template<typename BitStream > |
| void | skip_bytes (BitStream &bs, size_t bytes_needed) |
| |
| template<typename BitStream , typename TestValue > |
| void | skip_until (BitStream &bs, TestValue const &v) |
| |
| template<typename BitStream , typename TestValue > |
| void | skip_until (BitStream &bs, TestValue const &v, size_t bit_count) |
| |
| template<typename RandomIterator , typename Compare = std::less<>> |
| constexpr void | sort (RandomIterator first, RandomIterator last, Compare &&comp=Compare{ }) noexcept(sort_n_details::is_nothrow_sortable_v< RandomIterator, Compare >) |
| |
| template<typename RandomIterator , typename Compare = std::less<>> |
| constexpr void | sort_16 (RandomIterator first, Compare &&comp=Compare{ }) noexcept |
| |
| template<typename RandomIterator , typename Compare = std::less<>> |
| constexpr void | sort_3 (RandomIterator first, Compare &&comp=Compare{ }) noexcept |
| |
| template<typename RandomIterator , typename Compare = std::less<>> |
| constexpr void | sort_32 (RandomIterator first, Compare &&comp=Compare{ }) noexcept |
| |
| template<typename RandomIterator , typename Compare = std::less<>> |
| constexpr void | sort_4 (RandomIterator first, Compare &&comp=Compare{ }) noexcept |
| |
| template<typename RandomIterator , typename Compare = std::less<>> |
| constexpr void | sort_5 (RandomIterator first, Compare &&comp=Compare{ }) noexcept |
| |
| template<typename RandomIterator , typename Compare = std::less<>> |
| constexpr void | sort_6 (RandomIterator first, Compare &&comp=Compare{ }) noexcept |
| |
| template<typename RandomIterator , typename Compare = std::less<>> |
| constexpr void | sort_7 (RandomIterator first, Compare &&comp=Compare{ }) noexcept |
| |
| template<typename RandomIterator , typename Compare = std::less<>> |
| constexpr void | sort_8 (RandomIterator first, Compare &&comp=Compare{ }) noexcept |
| |
| template<typename ForwardIterator , typename RandomOutputIterator , typename Compare = std::less<>, std::enable_if_t< std::is_integral_v< typename std::iterator_traits< ForwardIterator >::value_type >, std::nullptr_t > = nullptr> |
| constexpr RandomOutputIterator | sort_to (ForwardIterator first_in, ForwardIterator last_in, RandomOutputIterator first_out, Compare &&comp=Compare{ }) |
| |
| template<typename InputIterator , typename RandomOutputIterator , typename Compare = std::less<>, std::enable_if_t< not std::is_integral_v< typename std::iterator_traits< InputIterator >::value_type >, std::nullptr_t > = nullptr> |
| constexpr RandomOutputIterator | sort_to (InputIterator first_in, InputIterator last_in, RandomOutputIterator first_out, Compare &&comp=Compare{ }) |
| |
| template<typename Container > |
| | span (Container &) -> span< std::remove_reference_t< decltype(*std::data(std::declval< Container >()))> > |
| |
| template<typename Container > |
| | span (Container const &) -> span< DAW_TYPEOF(*std::data(std::declval< Container >())) const > |
| |
| template<typename T > |
| | span (T *, size_t) -> span< T > |
| |
| template<typename T > |
| | span (T *, T *) -> span< T > |
| |
| template<typename T > |
| | span (T *, T const *) -> span< T > |
| |
| template<typename T , size_t N> |
| | span (T const (&)[N]) -> span< T const > |
| |
| template<typename T > |
| | span (T const *, size_t) -> span< T const > |
| |
| template<typename T > |
| | span (T const *, T *) -> span< T const > |
| |
| template<typename T > |
| | span (T const *, T const *) -> span< T const > |
| |
| template<typename T , size_t N> |
| | span (T(&)[N]) -> span< T > |
| |
| template<std::ranges::contiguous_range R> |
| | span_writer (R) -> span_writer< std::ranges::range_value_t< R > > |
| |
| template<std::ranges::contiguous_range R> |
| | span_writer (R, std::size_t) -> span_writer< std::ranges::range_value_t< R > > |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| auto | split (daw::basic_bounded_string< CharT, Capacity > &&str, CharT const (&delemiter)[N])=delete |
| |
| template<typename CharT , size_t Capacity> |
| auto | split (daw::basic_bounded_string< CharT, Capacity > &&str, CharT const delemiter)=delete |
| |
| template<typename CharT , size_t Capacity, size_t N> |
| auto | split (daw::basic_bounded_string< CharT, Capacity > const &str, CharT const (&delemiter)[N]) |
| |
| template<typename CharT , size_t Capacity> |
| auto | split (daw::basic_bounded_string< CharT, Capacity > const &str, CharT const delemiter) |
| |
| template<typename CharT , size_t N, typename UnaryPredicate > |
| auto | split (daw::basic_bounded_string< CharT, N > &&str, UnaryPredicate pred)=delete |
| |
| template<typename CharT , size_t N, typename UnaryPredicate > |
| auto | split (daw::basic_bounded_string< CharT, N > const &str, UnaryPredicate pred) |
| |
| template<std::size_t StartN, std::size_t EndN, typename... Args, std::enable_if_t<(sizeof...(Args) >=EndN), std::nullptr_t > = nullptr> |
| constexpr auto | split_args (std::tuple< Args... > args) |
| |
| template<std::size_t StartN, typename... Args, std::size_t... Is, std::enable_if_t<(sizeof...(Args) >=(sizeof...(Is)+StartN)), std::nullptr_t > = nullptr> |
| constexpr auto | split_args_impl (std::tuple< Args... > &&args, std::index_sequence< Is... >) |
| |
| template<typename CharT , typename Bounds = daw::sv1::default_string_view_bounds_type, size_t N, size_t M> |
| constexpr string_split_range< CharT > | split_string (CharT const (&str)[N], CharT const (&delemiter)[M]) noexcept |
| |
| template<typename CharT > |
| constexpr string_split_range< CharT > | split_string (daw::sv1::basic_string_view< CharT > str, daw::sv1::basic_string_view< CharT > delemiter) noexcept |
| |
| template<typename CharT , typename Bounds , std::ptrdiff_t Ex, size_t N> |
| constexpr string_split_range< CharT > | split_string (daw::sv1::basic_string_view< CharT, Bounds, Ex > str, CharT const (&delemiter)[N]) noexcept |
| |
| template<typename CharT , daw::sv2::string_view_bounds_type Bounds, std::ptrdiff_t Ex, size_t N> |
| constexpr string_split_range< CharT > | split_string (daw::sv2::basic_string_view< CharT, Bounds > str, CharT const (&delemiter)[N]) noexcept |
| |
| template<typename CharT > |
| string_split_range< CharT > | split_string (std::basic_string< CharT > const &str, daw::sv1::basic_string_view< CharT > delemiter) noexcept |
| |
| template<typename CharT > |
| string_split_range< CharT > | split_string (std::basic_string< CharT > const &str, std::basic_string< CharT > &delemiter) noexcept |
| |
| template<typename... Strings> |
| std::string | string_concat (std::string arg, Strings &&...strings) |
| |
| template<typename CharT > |
| | string_split_iterator (daw::sv1::basic_string_view< CharT >, daw::sv1::basic_string_view< CharT >) -> string_split_iterator< CharT > |
| |
| template<typename CharT > |
| | string_split_range (daw::sv1::basic_string_view< CharT >, daw::sv1::basic_string_view< CharT >) -> string_split_range< CharT > |
| |
| template<typename CharT , size_t N> |
| constexpr void | swap (basic_bounded_string< CharT, N > &lhs, basic_bounded_string< CharT, N > &rhs) noexcept |
| |
| template<typename T , size_t N> |
| constexpr void | swap (carray< T, N > &lhs, carray< T, N > &rhs) noexcept(std::is_nothrow_move_assignable_v< T >) |
| |
| template<class T1 , class T2 > |
| constexpr void | swap (compressed_pair< T1, T2 > &x, compressed_pair< T1, T2 > &y) noexcept(std::is_nothrow_swappable_v< T1 > and std::is_nothrow_swappable_v< T2 >) |
| |
| template<typename T , typename Deleter > |
| constexpr void | swap (copiable_unique_ptr< T, Deleter > &lhs, copiable_unique_ptr< T, Deleter > &rhs) noexcept |
| |
| template<typename... Args> |
| void | swap (CString< Args... > &lhs, CString< Args... > &rhs) noexcept |
| |
| template<typename T > |
| constexpr void | swap (daw::heap_array< T > &lhs, daw::heap_array< T > &rhs) noexcept |
| |
| template<typename T > |
| void | swap (daw::optional_poly< T > &lhs, daw::optional_poly< T > &rhs) noexcept |
| |
| template<typename T > |
| void | swap (hash_table< T > &lhs, hash_table< T > &rhs) noexcept |
| |
| template<typename T > |
| void | swap (hash_table_item_iterator< T > &lhs, hash_table_item_iterator< T > &rhs) noexcept |
| |
| template<typename T > |
| void | swap (heap_value< T > &lhs, heap_value< T > &rhs) noexcept |
| |
| template<typename T , typename D > |
| constexpr void | swap (rc_ptr< T, D > &lhs, rc_ptr< T, D > &rhs) |
| |
| template<class T , class Allocator > |
| constexpr void | swap (split_buffer< T, Allocator > &x, split_buffer< T, Allocator > &y) noexcept(noexcept(x.swap(y))) |
| |
| template<typename T > |
| constexpr void | swap (value_ptr< T > &lhs, value_ptr< T > &rhs) noexcept(noexcept(lhs.swap(rhs))) |
| |
| template<typename T , typename Allocator > |
| constexpr void | swap (vector< T, Allocator > &x, vector< T, Allocator > &y) noexcept(noexcept(x.swap(y))) |
| |
| template<typename ForwardIterator1 , typename ForwardIterator2 > |
| constexpr ForwardIterator2 | swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2) noexcept(noexcept(daw::iter_swap(first1, first2))) |
| |
| template<typename T , std::enable_if_t< std::is_default_constructible_v< T >, std::nullptr_t > = nullptr> |
| constexpr T | take (T &value) noexcept(std::is_nothrow_move_constructible_v< T > and std::is_nothrow_default_constructible_v< T >) |
| |
| template<typename... Ts> |
| constexpr tuple< Ts &... > | tie (Ts &...ts) noexcept |
| |
| template<typename T > |
| constexpr T * | to_address (T *p) noexcept |
| |
| template<typename T > |
| constexpr auto | to_address (T const &p) noexcept |
| |
| template<typename T , std::size_t N> |
| constexpr std::array< std::remove_cv_t< T >, N > | to_array (T(&a)[N]) |
| |
| template<typename To , typename From > |
| auto | to_array_of (From &&from) noexcept |
| |
| template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr> |
| constexpr T | to_big_endian (T value) noexcept |
| |
| template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr> |
| constexpr T | to_little_endian (T value) noexcept |
| |
| template<endian SourceEndian, typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr> |
| constexpr T | to_native_endian (T value) noexcept |
| |
| template<typename CharT , typename OutputIterator , typename Integer , typename Traits = daw::impl::char_traits<CharT>, std::enable_if_t< can_to_os_string_int_v< daw::remove_cvref_t< Integer > >, std::nullptr_t > = nullptr> |
| constexpr OutputIterator | to_os_string_int (OutputIterator it, Integer value) |
| |
| template<typename Iterator > |
| auto | to_reference_vector (Iterator first, Iterator last) |
| |
| template<typename Char > |
| std::string | to_string (CString< Char > const &str) |
| |
| template<size_t BitWidth> |
| std::string | to_string (static_bitset< BitWidth > const &bs) |
| |
| template<typename Number > |
| constexpr UInt16 | to_uint16 (Number num) |
| |
| template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr> |
| constexpr UInt16 | to_uint16_buffer (CharT const *ptr) noexcept |
| |
| template<typename Number > |
| constexpr UInt32 | to_uint32 (Number num) |
| |
| template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr> |
| constexpr UInt32 | to_uint32_buffer (CharT const *ptr) noexcept |
| |
| template<typename Number > |
| constexpr UInt64 | to_uint64 (Number num) |
| |
| template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr> |
| constexpr UInt64 | to_uint64_buffer (CharT const *ptr) noexcept |
| |
| template<typename Number > |
| constexpr UInt8 | to_uint8 (Number num) |
| |
| template<typename Enum , std::enable_if_t< std::is_enum_v< Enum >, std::nullptr_t > = nullptr> |
| constexpr auto | to_underlying (Enum e) |
| |
| template<typename T , typename Function , typename Compare = daw::graph_alg_impl::NoSort> |
| void | topological_sorted_walk (daw::graph_t< T > &graph, Function &&func, Compare comp=Compare{ }) |
| |
| template<typename T , typename Function , typename Compare = daw::graph_alg_impl::NoSort> |
| void | topological_sorted_walk (daw::graph_t< T > const &graph, Function &&func, Compare comp=Compare{ }) |
| |
| template<typename Map , typename Key > |
| constexpr auto | try_get (Map &container, Key &&k) |
| |
| template<typename Map , typename Key > |
| constexpr auto | try_get (Map const &container, Key &&k) |
| |
| template<typename... Ts> |
| | tuple (Ts...) -> tuple< Ts... > |
| |
| template<typename... Ts> |
| | tuple2 (Ts...) -> tuple2< Ts... > |
| |
| constexpr tuple2 | tuple2_cat () |
| |
| template<typename T0 , typename T1 , typename... Tps> |
| constexpr auto | tuple2_cat (T0 &&t0, T1 &&t1, Tps &&...tps) |
| |
| template<typename Tuple > |
| constexpr tuple2 | tuple2_cat (Tuple &&tp) |
| |
| template<typename Integer , typename Bit , typename... Bits> |
| constexpr Integer | unset_bits (Integer i, Bit b, Bits... bs) noexcept |
| | set bits at positions specified by b,bs...
|
| |
| template<typename To > |
| constexpr uint16_t | value_from_chars (unsigned char const *ptr, std::integral_constant< size_t, sizeof(uint16_t)>) noexcept |
| |
| template<typename To > |
| constexpr uint32_t | value_from_chars (unsigned char const *ptr, std::integral_constant< size_t, sizeof(uint32_t)>) noexcept |
| |
| template<typename To > |
| constexpr uint64_t | value_from_chars (unsigned char const *ptr, std::integral_constant< size_t, sizeof(uint64_t)>) noexcept |
| |
| template<typename To > |
| constexpr uint8_t | value_from_chars (unsigned char const *ptr, std::integral_constant< size_t, sizeof(uint8_t)>) noexcept |
| |
| template<typename T > |
| constexpr auto | value_is (T &&value) -> daw::utility_details::value_is_utility_details< std::remove_reference_t< decltype(value)> > |
| |
| template<typename... Args, typename Stream > |
| decltype(auto) | values_from_stream (Stream &&s, daw::string_view delemiter) |
| | Extract specified argument types from a stream of character data.
|
| |
| template<typename... Args, typename Stream , typename Splitter , std::enable_if_t<(not parse_to_impl::has_str_member_v< Stream > and std::is_invocable_v< Splitter, daw::string_view >), std::nullptr_t > = nullptr> |
| decltype(auto) | values_from_stream (Stream &&stream, Splitter &&splitter) |
| | Extract specified argument types from a stream of character data.
|
| |
| template<typename T , typename... Args> |
| constexpr T | variant_cast (std::variant< Args... > &&var) |
| |
| template<typename T , typename... Args> |
| constexpr T | variant_cast (std::variant< Args... > &var) |
| |
| template<typename T , typename... Args> |
| constexpr T | variant_cast (std::variant< Args... > const &var) |
| |
| template<input_iterator InputIterator> |
| | vector (InputIterator, InputIterator) -> vector< iter_value_type< InputIterator >, std::allocator< iter_value_type< InputIterator > > > |
| |
| template<input_iterator InputIterator, Allocators Alloc> |
| | vector (InputIterator, InputIterator, Alloc) -> vector< iter_value_type< InputIterator >, Alloc > |
| |
| template<typename T , std::size_t N> |
| | Vector (T const (&)[N]) -> Vector< T > |
| |
| template<typename BidirectionalIterator > |
| | view (BidirectionalIterator, BidirectionalIterator) -> view< BidirectionalIterator > |
| |
| template<typename Variant , typename... Visitors> |
| constexpr decltype(auto) | visit (Variant &&var, Visitors &&...visitors) |
| |
| template<typename Result , typename Variant , typename... Visitors> |
| constexpr Result | visit (Variant &&var, Visitors &&...visitors) |
| |
| template<typename VisitedT , typename OrigT , typename Visitor > |
| DAW_CX_IF_BIT_CAST auto | visit_as (OrigT &value, Visitor &&visitor) |
| | Invokes a visitor on a reinterpretation of the provided value, allowing modification of the value via the provided visitor, and optionally returning a value from the visitor's result.
|
| |
| template<typename VisitedT , typename OrigT , typename Visitor > |
| DAW_CX_IF_BIT_CAST auto | visit_as (OrigT const &value, Visitor &&visitor) |
| | Invokes a visitor on a reinterpretation of the provided value.
|
| |
| template<typename Variant , typename... Visitors> |
| constexpr decltype(auto) | visit_nt (Variant &&var, Visitors &&...visitors) |
| |
| template<typename Result , typename Variant , typename... Visitors> |
| constexpr Result | visit_nt (Variant &&var, Visitors &&...visitors) |
| |
| template<typename... Args> |
| DAW_ATTRIB_NOINLINE void | vprint (FILE *fout, std::string_view fmt, Args &&...args) |
| |
| template<typename... Args> |
| DAW_ATTRIB_NOINLINE void | vprint (std::string_view fmt, Args &&...args) |
| |
| template<typename... Args> |
| DAW_ATTRIB_NOINLINE void | vprintln (FILE *f, std::string fmt, Args &&...args) |
| |
| template<typename... Args> |
| DAW_ATTRIB_NOINLINE void | vprintln (std::string fmt, Args &&...args) |
| |
| template<typename T > |
| constexpr std::span< T > | write_to_span (std::span< T > out, daw::explicitly_convertible_to< T > auto &&...values) |
| |
template<typename T , typename R >
requires ( std::ranges::contiguous_range<R> and daw::explicitly_convertible_to<std::ranges::range_reference_t<R>, T> ) |
| constexpr std::span< T > | write_to_span (std::span< T > out, R const &r) |
| |
template<typename T , std::size_t N>
requires ( daw::explicitly_convertible_to<char, T> ) |
| constexpr std::span< T > | write_to_span_ntz (std::span< T > out, char const (&str)[N]) |
| | Write a string literal, minus trailing zero to span.
|
| |
| template<typename... Containers> |
| | zip_container (Containers &&...) -> zip_container< Containers... > |
| |
| template<typename... Iterators> |
| | zip_iterator (Iterators...) -> zip_iterator< Iterators... > |
| |